hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f7e98cb746944a7e4975c6baf78de8ba894520f0 | 12,739 | cc | C++ | Code/Components/Analysis/analysis/current/preprocessing/Wavelet2D1D.cc | rtobar/askapsoft | 6bae06071d7d24f41abe3f2b7f9ee06cb0a9445e | [
"BSL-1.0",
"Apache-2.0",
"OpenSSL"
] | 1 | 2020-06-18T08:37:43.000Z | 2020-06-18T08:37:43.000Z | Code/Components/Analysis/analysis/current/preprocessing/Wavelet2D1D.cc | ATNF/askapsoft | d839c052d5c62ad8a511e58cd4b6548491a6006f | [
"BSL-1.0",
"Apache-2.0",
"OpenSSL"
] | null | null | null | Code/Components/Analysis/analysis/current/preprocessing/Wavelet2D1D.cc | ATNF/askapsoft | d839c052d5c62ad8a511e58cd4b6548491a6006f | [
"BSL-1.0",
"Apache-2.0",
"OpenSSL"
] | null | null | null | /// Wavelet2D1D.h
///
/// Lars Floer's 2D1D wavelet reconstruction algorithm
///
/// @copyright (c) 2011 CSIRO
/// Australia Telescope National Facility (ATNF)
/// Commonwealth Scientific and Industrial Research Organisation (CSIRO)
/// PO Box 76, Epping NSW 1710, Australia
/// atnf-enquiries@csiro.au
///
/// This file is part of the ASKAP software distribution.
///
/// The ASKAP software distribution is free software: you can redistribute it
/// and/or modify it under the terms of the GNU General Public License as
/// published by the Free Software Foundation; either version 2 of the License,
/// or (at your option) any later version.
///
/// This program is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/// GNU General Public License for more details.
///
/// You should have received a copy of the GNU General Public License
/// along with this program; if not, write to the Free Software
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
///
/// @author Matthew Whiting <Matthew.Whiting@csiro.au>
///
#include <askap_analysis.h>
#include <preprocessing/Wavelet2D1D.h>
#include <askap/AskapLogging.h>
#include <askap/AskapError.h>
#include <math.h>
#include <fitsio.h>
#include <vector>
#include <iostream>
#include <algorithm>
#include <duchamp/param.hh>
#include <duchamp/Utils/utils.hh>
#include <duchamp/Utils/Statistics.hh>
using namespace std;
typedef unsigned long ulong;
typedef unsigned int uint;
ASKAP_LOGGER(logger, ".2d1drecon");
namespace askap {
namespace analysis {
// Convenience function for reflective boundary conditions
long inline reflectIndex(long index, size_t &dim)
{
while ((index < 0) || (index >= long(dim))) {
if (index < 0)
index = -index;
if (index >= long(dim))
index = 2 * (long(dim) - 1) - index;
}
return index;
}
Recon2D1D::Recon2D1D()
{
itsCube = 0;
itsFlagPositivity = true;
itsFlagDuchampStats = false;
itsReconThreshold = 3.;
itsMinXYScale = 1;
itsMaxXYScale = 0;
itsMinZScale = 1;
itsMaxZScale = 0;
itsNumIterations = 1;
}
Recon2D1D::Recon2D1D(const LOFAR::ParameterSet &parset)
{
itsFlagPositivity = parset.getBool("enforcePositivity", true);
itsFlagDuchampStats = parset.getBool("useDuchampStats", false);
itsReconThreshold = parset.getFloat("snrRecon", 3.0);
itsMinXYScale = parset.getUint16("minXYscale", 1);
itsMaxXYScale = parset.getUint16("maxXYscale", -1);
itsMinZScale = parset.getUint16("minZscale", 1);
itsMaxZScale = parset.getUint16("maxZscale", -1);
itsNumIterations = parset.getUint16("maxIter", 1);
}
void Recon2D1D::setCube(duchamp::Cube *cube)
{
itsCube = cube;
itsXdim = cube->getDimX();
itsYdim = cube->getDimY();
itsZdim = cube->getDimZ();
// NB: add +1 here since we have moved to assuming minimum scale =
// 1, not 0 as in Lars' original code.
uint xyScaleLimit = int(floor(log(std::min(itsXdim, itsYdim)) / M_LN2));
uint zScaleLimit = int(floor(log(itsZdim) / M_LN2));
if (itsMaxXYScale > 0) {
//parset provided a value
itsMaxXYScale = std::min(xyScaleLimit, itsMaxXYScale);
} else {
itsMaxXYScale = xyScaleLimit;
}
if (itsMinXYScale > xyScaleLimit) {
ASKAPLOG_WARN_STR(logger, "2D1D Recon: Requested minXYScale=" << itsMinXYScale << " exceeds maximum possible (" << xyScaleLimit << "). Setting minXYScale=" << xyScaleLimit);
itsMinXYScale = xyScaleLimit;
}
if (itsMaxZScale > 0) {
//parset provided a value
itsMaxZScale = std::min(zScaleLimit, itsMaxZScale);
} else {
itsMaxZScale = zScaleLimit;
}
if (itsMinZScale > zScaleLimit) {
ASKAPLOG_WARN_STR(logger, "2D1D Recon: Requested minZScale=" << itsMinZScale << " exceeds maximum possible (" << zScaleLimit << "). Setting minZScale=" << zScaleLimit);
itsMinZScale = zScaleLimit;
}
}
void Recon2D1D::reconstruct()
{
// use pointers to the arrays in itsCube so we write directly there.
float *input = itsCube->getArray();
float *output = itsCube->getRecon();
// Wavelet mother function stuff
float waveletMotherFunction[5] = {1. / 16., 4. / 16., 6. / 16., 4. / 16., 1. / 16.};
size_t motherFunctionSize = 5;
size_t motherFunctionHalfSize = motherFunctionSize / 2;
uint XYScaleFactor, ZScaleFactor;
ulong xPos, yPos, zPos, offset;
// Work array access indices
uint readFromXY = 0;
uint writeToXY = 1;
uint readFromZ = 0;
uint writeToZ = 0;
uint iteration = 0;
// Calculate data sizes
size_t xydim = itsXdim * itsYdim;
size_t size = xydim * itsZdim;
// Allocate the three work arrays
float *work[3];
float *origwork[3]; // this is used to track the original
// pointers for easy deletion at the end.
for (int i = 0; i < 3; i++) {
work[i] = new float[size];
origwork[i] = work[i];
}
// Check for bad values and initialize the output to 0.
// Use the makeBlankMask function of the duchamp::Cube class
std::vector<bool> isGood = itsCube->makeBlankMask();
for (size_t i = 0; i < size; i++) {
output[i] = 0.;
}
// Start the iteration loop
do {
// (Re)set the spatial scale factor that determines the step sizes
// in between the wavelet mother function coefficients
XYScaleFactor = 1;
// Initialize the first work array to the input data or residual from the previous iteration
for (ulong i = 0; i < size; i++) {
work[0][i] = isGood[i] ? input[i] - output[i] : 0.;
}
for (uint XYScale = itsMinXYScale; XYScale <= itsMaxXYScale; XYScale++) {
if (XYScale < itsMaxXYScale) {
// Convolve the x dimension with the wavelet mother function
// and approriate step size
for (size_t i = 0; i < size; i++) {
xPos = i % itsXdim;
yPos = (i % xydim) / itsXdim;
zPos = i / xydim;
offset = yPos * itsXdim + zPos * xydim;
long filterPos = xPos - XYScaleFactor * motherFunctionHalfSize;
work[2][i] = 0.;
if (isGood[i]) {
for (size_t j = 0; j < motherFunctionSize; j++) {
size_t loc = offset + reflectIndex(filterPos, itsXdim) * 1;
if (isGood[loc]) {
work[2][i] += work[readFromXY][loc] * waveletMotherFunction[j];
}
filterPos += XYScaleFactor;
}
}
}
// Convolve the y dimension with the wavelet mother function
// and appropriate step size
for (size_t i = 0; i < size; i++) {
xPos = i % itsXdim;
yPos = (i % xydim) / itsXdim;
zPos = i / xydim;
offset = xPos + zPos * xydim;
long filterPos = yPos - XYScaleFactor * motherFunctionHalfSize;
work[writeToXY][i] = 0.;
if (isGood[i]) {
for (size_t j = 0; j < motherFunctionSize; j++) {
size_t loc = offset + reflectIndex(filterPos, itsYdim) * itsXdim;
if (isGood[loc]) {
work[writeToXY][i] += work[2][loc] * waveletMotherFunction[j];
}
filterPos += XYScaleFactor;
}
}
}
// Exchange the work array access indices
readFromXY = (readFromXY + 1) % 2;
writeToXY = (writeToXY + 1) % 2;
// Calculate the spatial wavelet coefficients
for (size_t i = 0; i < size; i++) {
work[writeToXY][i] -= work[readFromXY][i];
}
} else {
work[writeToXY] = work[readFromXY];
}
// set the access indices for the spectral loop
readFromZ = writeToXY;
writeToZ = 2;
// Set the spectral scale factor and work array access indices
ZScaleFactor = 1;
for (uint ZScale = itsMinZScale; ZScale <= itsMaxZScale; ZScale++) {
// Convolve the z dimension of the spatial wavelet coefficients
// with the wavelet mother function and appropriate step size
for (size_t i = 0; i < size; i++) {
xPos = i % itsXdim;
yPos = (i % xydim) / itsXdim;
zPos = i / xydim;
offset = xPos + yPos * itsXdim;
long filterPos = zPos - ZScaleFactor * motherFunctionHalfSize;
work[writeToZ][i] = 0.;
if (isGood[i]) {
for (size_t j = 0; j < motherFunctionSize; j++) {
size_t loc = offset + reflectIndex(filterPos, itsZdim) * xydim;
if (isGood[loc]) {
work[writeToZ][i] += (work[readFromZ][loc] *
waveletMotherFunction[j]);
}
filterPos += ZScaleFactor;
}
}
}
// Exchange to work array access indices
if (writeToZ == 2) {
readFromZ = 2;
writeToZ = writeToXY;
} else {
readFromZ = writeToXY;
writeToZ = 2;
}
// Only treat coefficients if the desired minimal scale is reached
if ((XYScale >= itsMinXYScale) && (ZScale >= itsMinZScale)) {
// Calculate the spectral wavelet coefficients
for (size_t i = 0; i < size; i++) {
work[writeToZ][i] -= work[readFromZ][i];
}
// Calculate statistics for the given wavelet coefficients
// Could be replaced with robust or position dependent statistics
double std = 0;
size_t goodSize = 0;
for (size_t i = 0; i < size; i++) {
if (isGood[i]) {
std += work[writeToZ][i] * work[writeToZ][i];
goodSize++;
}
}
std = sqrt(std / (goodSize + 1));
float middle, spread;
if (itsCube->pars().getFlagRobustStats()) {
findMedianStats<float>(work[writeToZ], size, isGood, middle, spread);
spread = Statistics::madfmToSigma(spread);
} else {
findNormalStats<float>(work[writeToZ], size, isGood, middle, spread);
}
// Threshold coefficients
for (size_t i = 0; i < size; i++) {
bool checkFlux;
if (itsFlagDuchampStats) {
checkFlux = (fabs(work[writeToZ][i] - middle) >
itsReconThreshold * spread);
} else {
checkFlux = (fabs(work[writeToZ][i]) > itsReconThreshold * std);
}
if (checkFlux && isGood[i]) {
output[i] += work[writeToZ][i];
}
}
}
// Increase spectral scale factor
ZScaleFactor *= 2;
}
// Increase spatial scale factor
XYScaleFactor *= 2;
}
// Enforce positivity on the (intermediate) solution
// Greatly improves the reconstruction quality
if (itsFlagPositivity) {
for (size_t i = 0; i < size; i++)
if (output[i] < 0 || !isGood[i]) {
output[i] = 0;
}
}
// Increase the iteration counter and check for iteration break
iteration++;
} while (iteration < itsNumIterations);
for (int i = 2; i >= 0; i--) {
delete [] origwork[i];
}
itsCube->setReconFlag(true);
}
}
}
| 35.093664 | 181 | 0.52406 | rtobar |
f7edf5ec82381548ad4ebc4bcaadecd56b8535b6 | 622 | cpp | C++ | Cpp/1008.construct-binary-search-tree-from-preorder-traversal.cpp | zszyellow/leetcode | 2ef6be04c3008068f8116bf28d70586e613a48c2 | [
"MIT"
] | 1 | 2015-12-19T23:05:35.000Z | 2015-12-19T23:05:35.000Z | Cpp/1008.construct-binary-search-tree-from-preorder-traversal.cpp | zszyellow/leetcode | 2ef6be04c3008068f8116bf28d70586e613a48c2 | [
"MIT"
] | null | null | null | Cpp/1008.construct-binary-search-tree-from-preorder-traversal.cpp | zszyellow/leetcode | 2ef6be04c3008068f8116bf28d70586e613a48c2 | [
"MIT"
] | null | null | 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:
TreeNode* bstFromPreorder(vector<int>& preorder) {
int i = 0;
return build(preorder, i, INT_MAX);
}
TreeNode* build(vector<int>& A, int& i, int bound) {
if (i == A.size() || A[i] > bound) return NULL;
TreeNode* root = new TreeNode(A[i++]);
root->left = build(A, i, root->val);
root->right = build(A, i, bound);
return root;
}
}; | 25.916667 | 59 | 0.538585 | zszyellow |
f7edf703c84b774df1e0f62b471141fb40d93d3c | 643 | cpp | C++ | 0001-0100/3-longest-substring-without-repeating-characters/main.cpp | janreggie/leetcode | c59718e127b598c4de7d07c9c93064eb12b2e5c9 | [
"MIT",
"Unlicense"
] | null | null | null | 0001-0100/3-longest-substring-without-repeating-characters/main.cpp | janreggie/leetcode | c59718e127b598c4de7d07c9c93064eb12b2e5c9 | [
"MIT",
"Unlicense"
] | null | null | null | 0001-0100/3-longest-substring-without-repeating-characters/main.cpp | janreggie/leetcode | c59718e127b598c4de7d07c9c93064eb12b2e5c9 | [
"MIT",
"Unlicense"
] | null | null | null | #include <algorithm>
#include <string>
#include <unordered_set>
class Solution
{
public:
int lengthOfLongestSubstring(const std::string& s)
{
std::unordered_map<char, size_t> inds; // inds[c] = last index of c
size_t a = 0, b = 0;
size_t record = 0; // largest b-a
// Now what is our loop condition?
while (true) {
while (b < s.size() && (inds.count(s.at(b)) == 0 || inds.at(s.at(b)) < a)) {
inds[s.at(b)] = b;
++b;
}
record = std::max(record, b - a);
// At this point, either b == s.size() or s.at(b) in letters
if (b == s.size()) {
break;
}
a = inds[s.at(b)] + 1;
}
return record;
}
};
| 19.484848 | 79 | 0.562986 | janreggie |
f7f5152770a5683957f586d6b85c1e8a7bd54f80 | 1,908 | cpp | C++ | Concurrency/Print Zero Even Odd/solution.cpp | MishaVernik/LeetCode | 5f4823706f472b59fbc0c936524477dc039a46ee | [
"MIT"
] | null | null | null | Concurrency/Print Zero Even Odd/solution.cpp | MishaVernik/LeetCode | 5f4823706f472b59fbc0c936524477dc039a46ee | [
"MIT"
] | null | null | null | Concurrency/Print Zero Even Odd/solution.cpp | MishaVernik/LeetCode | 5f4823706f472b59fbc0c936524477dc039a46ee | [
"MIT"
] | null | null | null | /*
Suppose you are given the following code:
class ZeroEvenOdd {
public ZeroEvenOdd(int n) { ... } // constructor
public void zero(printNumber) { ... } // only output 0's
public void even(printNumber) { ... } // only output even numbers
public void odd(printNumber) { ... } // only output odd numbers
}
The same instance of ZeroEvenOdd will be passed to three different threads:
Thread A will call zero() which should only output 0's.
Thread B will call even() which should only ouput even numbers.
Thread C will call odd() which should only output odd numbers.
Each of the thread is given a printNumber method to output an integer. Modify the given program to output the series 010203040506... where the length of the series must be 2n.
Example 1:
Input: n = 2
Output: "0102"
Explanation: There are three threads being fired asynchronously. One of them calls zero(), the other calls even(), and the last one calls odd(). "0102" is the correct output.
Example 2:
Input: n = 5
Output: "0102030405"
*/
class ZeroEvenOdd {
private:
int n;
int t;
mutex m1,m2,m3;
public:
ZeroEvenOdd(int n) {
this->n = n;
m1.lock();
m2.lock();
m3.lock();
t = 0;
}
void zero(function<void(int)> printNumber) {
m3.unlock();
for (int i = 0; i < n; i++){
m3.lock();
printNumber(0);
if (t == 0) t=1,m1.unlock();
else t=0,m2.unlock();
}
}
void even(function<void(int)> printNumber) {
for (int i = 2; i <= n; i+=2){
m2.lock();
printNumber(i);
m3.unlock();
}
}
void odd(function<void(int)> printNumber) {
for (int i = 1; i <= n; i+=2){
m1.lock();
printNumber(i);
m3.unlock();
}
}
}; | 27.257143 | 175 | 0.562369 | MishaVernik |
f7f680f9a48b27576bb8ba759460d22220c96263 | 141,776 | cpp | C++ | third_party/skia_m79/third_party/externals/angle2/src/libANGLE/capture_gles_ext_params.cpp | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | null | null | null | third_party/skia_m79/third_party/externals/angle2/src/libANGLE/capture_gles_ext_params.cpp | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | null | null | null | third_party/skia_m79/third_party/externals/angle2/src/libANGLE/capture_gles_ext_params.cpp | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | null | null | null | //
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_glesext_params.cpp:
// Pointer parameter capture functions for the OpenGL ES extension entry points.
#include "libANGLE/capture_gles_ext_autogen.h"
using namespace angle;
namespace gl
{
void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei count,
DrawElementsType typePacked,
const GLvoid *indices,
GLsizei instanceCounts,
GLint baseVertex,
GLuint baseInstance,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLint *firsts,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLint *firsts,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLint *firsts,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLint *firsts,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
DrawElementsType typePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLvoid *const *indices,
const GLint *baseVertices,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
DrawElementsType typePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLvoid *const *indices,
const GLint *baseVertices,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
DrawElementsType typePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLvoid *const *indices,
const GLint *baseVertices,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
DrawElementsType typePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLvoid *const *indices,
const GLint *baseVertices,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances(
const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
DrawElementsType typePacked,
GLsizei drawcount,
const GLsizei *counts,
const GLsizei *instanceCounts,
const GLvoid *const *indices,
const GLint *baseVertices,
const GLuint *baseInstances,
angle::ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawElementsInstancedANGLE_indices(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei count,
DrawElementsType typePacked,
const void *indices,
GLsizei primcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysANGLE_firsts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLint *firsts,
const GLsizei *counts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysANGLE_counts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLint *firsts,
const GLsizei *counts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedANGLE_firsts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLint *firsts,
const GLsizei *counts,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedANGLE_counts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLint *firsts,
const GLsizei *counts,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLint *firsts,
const GLsizei *counts,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsANGLE_counts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLsizei *counts,
DrawElementsType typePacked,
const GLvoid *const *indices,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsANGLE_indices(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLsizei *counts,
DrawElementsType typePacked,
const GLvoid *const *indices,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedANGLE_counts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLsizei *counts,
DrawElementsType typePacked,
const GLvoid *const *indices,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedANGLE_indices(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLsizei *counts,
DrawElementsType typePacked,
const GLvoid *const *indices,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
const GLsizei *counts,
DrawElementsType typePacked,
const GLvoid *const *indices,
const GLsizei *instanceCounts,
GLsizei drawcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureRequestExtensionANGLE_name(const Context *context,
bool isCallValid,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDisableExtensionANGLE_name(const Context *context,
bool isCallValid,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBooleanvRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLboolean *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBooleanvRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLboolean *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFloatvRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFloatvRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLenum attachment,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum attachment,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetIntegervRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetIntegervRobustANGLE_data(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetRenderbufferParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetRenderbufferParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetShaderivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID shader,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetShaderivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID shader,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterfvRobustANGLE_length(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterfvRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformfvRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformfvRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribfvRobustANGLE_length(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribfvRobustANGLE_params(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribivRobustANGLE_length(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribivRobustANGLE_params(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribPointervRobustANGLE_length(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **pointer,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribPointervRobustANGLE_pointer(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **pointer,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadPixelsRobustANGLE_length(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadPixelsRobustANGLE_columns(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadPixelsRobustANGLE_rows(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadPixelsRobustANGLE_pixels(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexImage2DRobustANGLE_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterfvRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
const GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
const GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexSubImage2DRobustANGLE_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexImage3DRobustANGLE_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLsizei depth,
GLint border,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexSubImage3DRobustANGLE_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLsizei width,
GLsizei height,
GLsizei depth,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexImage2DRobustANGLE_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLsizei imageSize,
GLsizei dataSize,
const GLvoid *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexSubImage2DRobustANGLE_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLsizei xoffset,
GLsizei yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLsizei imageSize,
GLsizei dataSize,
const GLvoid *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexImage3DRobustANGLE_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLsizei depth,
GLint border,
GLsizei imageSize,
GLsizei dataSize,
const GLvoid *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexSubImage3DRobustANGLE_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLsizei width,
GLsizei height,
GLsizei depth,
GLenum format,
GLsizei imageSize,
GLsizei dataSize,
const GLvoid *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryivRobustANGLE_length(const Context *context,
bool isCallValid,
QueryType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryivRobustANGLE_params(const Context *context,
bool isCallValid,
QueryType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectuivRobustANGLE_length(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectuivRobustANGLE_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferPointervRobustANGLE_length(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferPointervRobustANGLE_params(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetIntegeri_vRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetIntegeri_vRobustANGLE_data(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInternalformativRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLenum internalformat,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInternalformativRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum internalformat,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribIivRobustANGLE_length(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribIivRobustANGLE_params(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribIuivRobustANGLE_length(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetVertexAttribIuivRobustANGLE_params(const Context *context,
bool isCallValid,
GLuint index,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformuivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUniformuivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetActiveUniformBlockivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLuint uniformBlockIndex,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetActiveUniformBlockivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLuint uniformBlockIndex,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInteger64vRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInteger64vRobustANGLE_data(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInteger64i_vRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint64 *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetInteger64i_vRobustANGLE_data(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint64 *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferParameteri64vRobustANGLE_length(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferParameteri64vRobustANGLE_params(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterivRobustANGLE_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLuint pname,
GLsizei bufSize,
const GLint *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterfvRobustANGLE_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLfloat *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterfvRobustANGLE_length(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterfvRobustANGLE_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFramebufferParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFramebufferParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramInterfaceivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum programInterface,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramInterfaceivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum programInterface,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBooleani_vRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLboolean *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBooleani_vRobustANGLE_data(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLboolean *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetMultisamplefvRobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLfloat *val,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetMultisamplefvRobustANGLE_val(const Context *context,
bool isCallValid,
GLenum pname,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLfloat *val,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterivRobustANGLE_length(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterfvRobustANGLE_length(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterfvRobustANGLE_params(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetPointervRobustANGLERobustANGLE_length(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetPointervRobustANGLERobustANGLE_params(const Context *context,
bool isCallValid,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadnPixelsRobustANGLE_length(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadnPixelsRobustANGLE_columns(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadnPixelsRobustANGLE_rows(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadnPixelsRobustANGLE_data(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformfvRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformfvRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformuivRobustANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformuivRobustANGLE_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterIivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
const GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterIuivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
const GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIivRobustANGLE_length(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIuivRobustANGLE_length(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIuivRobustANGLE_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterIivRobustANGLE_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLint *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterIuivRobustANGLE_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLuint *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIivRobustANGLE_length(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIivRobustANGLE_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIuivRobustANGLE_length(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIuivRobustANGLE_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectivRobustANGLE_length(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectivRobustANGLE_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjecti64vRobustANGLE_length(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjecti64vRobustANGLE_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectui64vRobustANGLE_length(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectui64vRobustANGLE_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLsizei bufSize,
GLsizei *length,
GLuint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterivANGLE_params(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexLevelParameterfvANGLE_params(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum pname,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetMultisamplefvANGLE_val(const Context *context,
bool isCallValid,
GLenum pname,
GLuint index,
GLfloat *val,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTranslatedShaderSourceANGLE_length(const Context *context,
bool isCallValid,
ShaderProgramID shader,
GLsizei bufsize,
GLsizei *length,
GLchar *source,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTranslatedShaderSourceANGLE_source(const Context *context,
bool isCallValid,
ShaderProgramID shader,
GLsizei bufsize,
GLsizei *length,
GLchar *source,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureBindUniformLocationCHROMIUM_name(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMatrixLoadfCHROMIUM_matrix(const Context *context,
bool isCallValid,
GLenum matrixMode,
const GLfloat *matrix,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CapturePathCommandsCHROMIUM_commands(const Context *context,
bool isCallValid,
PathID path,
GLsizei numCommands,
const GLubyte *commands,
GLsizei numCoords,
GLenum coordType,
const void *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CapturePathCommandsCHROMIUM_coords(const Context *context,
bool isCallValid,
PathID path,
GLsizei numCommands,
const GLubyte *commands,
GLsizei numCoords,
GLenum coordType,
const void *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetPathParameterfvCHROMIUM_value(const Context *context,
bool isCallValid,
PathID path,
GLenum pname,
GLfloat *value,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetPathParameterivCHROMIUM_value(const Context *context,
bool isCallValid,
PathID path,
GLenum pname,
GLint *value,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCoverFillPathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCoverFillPathInstancedCHROMIUM_transformValues(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCoverStrokePathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCoverStrokePathInstancedCHROMIUM_transformValues(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilStrokePathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilStrokePathInstancedCHROMIUM_transformValues(const Context *context,
bool isCallValid,
GLsizei numPath,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilFillPathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilFillPathInstancedCHROMIUM_transformValues(const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilThenCoverFillPathInstancedCHROMIUM_transformValues(
const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLenum fillMode,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_paths(const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureStencilThenCoverStrokePathInstancedCHROMIUM_transformValues(
const Context *context,
bool isCallValid,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
PathID pathBase,
GLint reference,
GLuint mask,
GLenum coverMode,
GLenum transformType,
const GLfloat *transformValues,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureBindFragmentInputLocationCHROMIUM_name(const Context *context,
bool isCallValid,
ShaderProgramID programs,
GLint location,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureProgramPathFragmentInputGenCHROMIUM_coeffs(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLenum genMode,
GLint components,
const GLfloat *coeffs,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureBindFragDataLocationEXT_name(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLuint color,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureBindFragDataLocationIndexedEXT_name(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLuint colorNumber,
GLuint index,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFragDataIndexEXT_name(const Context *context,
bool isCallValid,
ShaderProgramID program,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramResourceLocationIndexEXT_name(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum programInterface,
const GLchar *name,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureInsertEventMarkerEXT_marker(const Context *context,
bool isCallValid,
GLsizei length,
const GLchar *marker,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CapturePushGroupMarkerEXT_marker(const Context *context,
bool isCallValid,
GLsizei length,
const GLchar *marker,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDiscardFramebufferEXT_attachments(const Context *context,
bool isCallValid,
GLenum target,
GLsizei numAttachments,
const GLenum *attachments,
ParamCapture *paramCapture)
{
CaptureMemory(attachments, sizeof(GLenum) * numAttachments, paramCapture);
}
void CaptureDeleteQueriesEXT_idsPacked(const Context *context,
bool isCallValid,
GLsizei n,
const QueryID *ids,
ParamCapture *paramCapture)
{
CaptureMemory(ids, sizeof(QueryID) * n, paramCapture);
}
void CaptureGenQueriesEXT_idsPacked(const Context *context,
bool isCallValid,
GLsizei n,
QueryID *ids,
ParamCapture *paramCapture)
{
CaptureGenHandles(n, ids, paramCapture);
}
void CaptureGetQueryObjecti64vEXT_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectivEXT_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectui64vEXT_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLuint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryObjectuivEXT_params(const Context *context,
bool isCallValid,
QueryID id,
GLenum pname,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetQueryivEXT_params(const Context *context,
bool isCallValid,
QueryType targetPacked,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawBuffersEXT_bufs(const Context *context,
bool isCallValid,
GLsizei n,
const GLenum *bufs,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawElementsInstancedEXT_indices(const Context *context,
bool isCallValid,
PrimitiveMode modePacked,
GLsizei count,
DrawElementsType typePacked,
const void *indices,
GLsizei primcount,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const Context *context,
bool isCallValid,
GLsizei n,
MemoryObjectID *memoryObjects,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const Context *context,
bool isCallValid,
GLsizei n,
const MemoryObjectID *memoryObjects,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetMemoryObjectParameterivEXT_params(const Context *context,
bool isCallValid,
MemoryObjectID memoryObject,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUnsignedBytevEXT_data(const Context *context,
bool isCallValid,
GLenum pname,
GLubyte *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetUnsignedBytei_vEXT_data(const Context *context,
bool isCallValid,
GLenum target,
GLuint index,
GLubyte *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMemoryObjectParameterivEXT_params(const Context *context,
bool isCallValid,
MemoryObjectID memoryObject,
GLenum pname,
const GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformfvEXT_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetnUniformivEXT_params(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLint location,
GLsizei bufSize,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureReadnPixelsEXT_data(const Context *context,
bool isCallValid,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteSemaphoresEXT_semaphoresPacked(const Context *context,
bool isCallValid,
GLsizei n,
const SemaphoreID *semaphores,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGenSemaphoresEXT_semaphoresPacked(const Context *context,
bool isCallValid,
GLsizei n,
SemaphoreID *semaphores,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSemaphoreParameterui64vEXT_params(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLenum pname,
GLuint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSemaphoreParameterui64vEXT_params(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLenum pname,
const GLuint64 *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSignalSemaphoreEXT_buffersPacked(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *dstLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSignalSemaphoreEXT_texturesPacked(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *dstLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSignalSemaphoreEXT_dstLayouts(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *dstLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureWaitSemaphoreEXT_buffersPacked(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *srcLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureWaitSemaphoreEXT_texturesPacked(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *srcLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureWaitSemaphoreEXT_srcLayouts(const Context *context,
bool isCallValid,
SemaphoreID semaphore,
GLuint numBufferBarriers,
const BufferID *buffers,
GLuint numTextureBarriers,
const TextureID *textures,
const GLenum *srcLayouts,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDebugMessageCallbackKHR_userParam(const Context *context,
bool isCallValid,
GLDEBUGPROCKHR callback,
const void *userParam,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDebugMessageControlKHR_ids(const Context *context,
bool isCallValid,
GLenum source,
GLenum type,
GLenum severity,
GLsizei count,
const GLuint *ids,
GLboolean enabled,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDebugMessageInsertKHR_buf(const Context *context,
bool isCallValid,
GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar *buf,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_sources(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_types(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_ids(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_severities(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_lengths(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetDebugMessageLogKHR_messageLog(const Context *context,
bool isCallValid,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetObjectLabelKHR_length(const Context *context,
bool isCallValid,
GLenum identifier,
GLuint name,
GLsizei bufSize,
GLsizei *length,
GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetObjectLabelKHR_label(const Context *context,
bool isCallValid,
GLenum identifier,
GLuint name,
GLsizei bufSize,
GLsizei *length,
GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetObjectPtrLabelKHR_ptr(const Context *context,
bool isCallValid,
const void *ptr,
GLsizei bufSize,
GLsizei *length,
GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetObjectPtrLabelKHR_length(const Context *context,
bool isCallValid,
const void *ptr,
GLsizei bufSize,
GLsizei *length,
GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetObjectPtrLabelKHR_label(const Context *context,
bool isCallValid,
const void *ptr,
GLsizei bufSize,
GLsizei *length,
GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetPointervKHR_params(const Context *context,
bool isCallValid,
GLenum pname,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureObjectLabelKHR_label(const Context *context,
bool isCallValid,
GLenum identifier,
GLuint name,
GLsizei length,
const GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureObjectPtrLabelKHR_ptr(const Context *context,
bool isCallValid,
const void *ptr,
GLsizei length,
const GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureObjectPtrLabelKHR_label(const Context *context,
bool isCallValid,
const void *ptr,
GLsizei length,
const GLchar *label,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CapturePushDebugGroupKHR_message(const Context *context,
bool isCallValid,
GLenum source,
GLuint id,
GLsizei length,
const GLchar *message,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteFencesNV_fencesPacked(const Context *context,
bool isCallValid,
GLsizei n,
const FenceNVID *fences,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGenFencesNV_fencesPacked(const Context *context,
bool isCallValid,
GLsizei n,
FenceNVID *fences,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFenceivNV_params(const Context *context,
bool isCallValid,
FenceNVID fence,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawTexfvOES_coords(const Context *context,
bool isCallValid,
const GLfloat *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawTexivOES_coords(const Context *context,
bool isCallValid,
const GLint *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawTexsvOES_coords(const Context *context,
bool isCallValid,
const GLshort *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDrawTexxvOES_coords(const Context *context,
bool isCallValid,
const GLfixed *coords,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteFramebuffersOES_framebuffersPacked(const Context *context,
bool isCallValid,
GLsizei n,
const FramebufferID *framebuffers,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const Context *context,
bool isCallValid,
GLsizei n,
const RenderbufferID *renderbuffers,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGenFramebuffersOES_framebuffersPacked(const Context *context,
bool isCallValid,
GLsizei n,
FramebufferID *framebuffers,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGenRenderbuffersOES_renderbuffersPacked(const Context *context,
bool isCallValid,
GLsizei n,
RenderbufferID *renderbuffers,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetFramebufferAttachmentParameterivOES_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum attachment,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetRenderbufferParameterivOES_params(const Context *context,
bool isCallValid,
GLenum target,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramBinaryOES_length(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLsizei bufSize,
GLsizei *length,
GLenum *binaryFormat,
void *binary,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramBinaryOES_binaryFormat(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLsizei bufSize,
GLsizei *length,
GLenum *binaryFormat,
void *binary,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetProgramBinaryOES_binary(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLsizei bufSize,
GLsizei *length,
GLenum *binaryFormat,
void *binary,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureProgramBinaryOES_binary(const Context *context,
bool isCallValid,
ShaderProgramID program,
GLenum binaryFormat,
const void *binary,
GLint length,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetBufferPointervOES_params(const Context *context,
bool isCallValid,
BufferBinding targetPacked,
GLenum pname,
void **params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureMatrixIndexPointerOES_pointer(const Context *context,
bool isCallValid,
GLint size,
GLenum type,
GLsizei stride,
const void *pointer,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureWeightPointerOES_pointer(const Context *context,
bool isCallValid,
GLint size,
GLenum type,
GLsizei stride,
const void *pointer,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CapturePointSizePointerOES_pointer(const Context *context,
bool isCallValid,
VertexAttribType typePacked,
GLsizei stride,
const void *pointer,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureQueryMatrixxOES_mantissa(const Context *context,
bool isCallValid,
GLfixed *mantissa,
GLint *exponent,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureQueryMatrixxOES_exponent(const Context *context,
bool isCallValid,
GLfixed *mantissa,
GLint *exponent,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexImage3DOES_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLsizei depth,
GLint border,
GLsizei imageSize,
const void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureCompressedTexSubImage3DOES_data(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLsizei width,
GLsizei height,
GLsizei depth,
GLenum format,
GLsizei imageSize,
const void *data,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexImage3DOES_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLsizei depth,
GLint border,
GLenum format,
GLenum type,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexSubImage3DOES_pixels(const Context *context,
bool isCallValid,
TextureTarget targetPacked,
GLint level,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLsizei width,
GLsizei height,
GLsizei depth,
GLenum format,
GLenum type,
const void *pixels,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIivOES_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetSamplerParameterIuivOES_params(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIivOES_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexParameterIuivOES_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterIivOES_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
const GLint *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureSamplerParameterIuivOES_param(const Context *context,
bool isCallValid,
SamplerID sampler,
GLenum pname,
const GLuint *param,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterIivOES_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
const GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexParameterIuivOES_params(const Context *context,
bool isCallValid,
TextureType targetPacked,
GLenum pname,
const GLuint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexGenfvOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexGenivOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGetTexGenxvOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
GLfixed *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexGenfvOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
const GLfloat *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexGenivOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
const GLint *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureTexGenxvOES_params(const Context *context,
bool isCallValid,
GLenum coord,
GLenum pname,
const GLfixed *params,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureDeleteVertexArraysOES_arraysPacked(const Context *context,
bool isCallValid,
GLsizei n,
const VertexArrayID *arrays,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
void CaptureGenVertexArraysOES_arraysPacked(const Context *context,
bool isCallValid,
GLsizei n,
VertexArrayID *arrays,
ParamCapture *paramCapture)
{
UNIMPLEMENTED();
}
} // namespace gl
| 44.780796 | 95 | 0.351766 | kniefliu |
f7f6eaf345aa924b4e1543e79c311b0c9ee1eb7c | 806 | cpp | C++ | control_app/main.cpp | houcy/wall-e-1 | b159d05b0afa343cb161f60ec98974bc2f063afd | [
"MIT"
] | 1 | 2021-05-05T14:11:03.000Z | 2021-05-05T14:11:03.000Z | control_app/main.cpp | houcy/wall-e-1 | b159d05b0afa343cb161f60ec98974bc2f063afd | [
"MIT"
] | null | null | null | control_app/main.cpp | houcy/wall-e-1 | b159d05b0afa343cb161f60ec98974bc2f063afd | [
"MIT"
] | null | null | null | #include "main_widget.h"
#include "tcp_server.h"
#include "log.h"
#include "common.h"
#include <QApplication>
#ifdef Q_WS_QWS
#include <QAbstractSlider>
#include <QWSServer>
#endif
void outOfMemHandler()
{
fatal("Failed to allocate memory");
}
int main(int argc, char *argv[])
{
std::set_new_handler(outOfMemHandler);
QApplication a(argc, argv);
QCoreApplication::setOrganizationName(COMPANY_NAME);
QCoreApplication::setApplicationName(APPLICATION_NAME);
MainWidget mainWidget;
#ifdef Q_WS_QWS
QList<QAbstractSlider *> sliders = mainWidget.findChildren<QAbstractSlider *>();
foreach (QAbstractSlider *slider, sliders)
slider->setAttribute(Qt::WA_AcceptTouchEvents);
QWSServer::setCursorVisible(false);
#endif
mainWidget.show();
return a.exec();
}
| 21.783784 | 84 | 0.729529 | houcy |
f7f6fd54f4469ad46aeab6dcf21e8350579fe795 | 6,306 | cpp | C++ | source/hydra_next/source/graphics/debug_renderer.cpp | JorenJoestar/DataDrivenRendering | b9078ea3d2d63d1c2cbc6f9ed655e49e23747969 | [
"Zlib"
] | 164 | 2019-06-30T18:14:38.000Z | 2022-03-13T14:36:10.000Z | source/hydra_next/source/graphics/debug_renderer.cpp | JorenJoestar/DataDrivenRendering | b9078ea3d2d63d1c2cbc6f9ed655e49e23747969 | [
"Zlib"
] | null | null | null | source/hydra_next/source/graphics/debug_renderer.cpp | JorenJoestar/DataDrivenRendering | b9078ea3d2d63d1c2cbc6f9ed655e49e23747969 | [
"Zlib"
] | 11 | 2019-09-11T13:40:59.000Z | 2022-01-28T09:24:24.000Z | #include "graphics/debug_renderer.hpp"
#include "graphics/camera.hpp"
#include "graphics/command_buffer.hpp"
namespace hydra {
namespace gfx {
//
//
struct LineVertex {
vec3s position;
hydra::Color color;
void set( vec3s position_, hydra::Color color_ ) { position = position_; color = color_; }
void set( vec2s position_, hydra::Color color_ ) { position = { position_.x, position_.y, 0 }; color = color_; }
}; // struct LineVertex
//
//
struct LineVertex2D {
vec2s position;
u32 color;
}; // struct LineVertex2D
static const u32 k_max_lines = 100000;
static LineVertex s_line_buffer[ k_max_lines ];
static LineVertex2D s_line_buffer_2d[ k_max_lines ];
struct LinesGPULocalConstants {
mat4s view_projection;
mat4s projection;
vec4s resolution;
f32 line_width;
f32 pad[ 3 ];
};
// DebugRenderer ////////////////////////////////////////////////////////////////
void DebugRenderer::init( hydra::gfx::Renderer* renderer ) {
using namespace hydra::gfx;
// Constants
lines_cb = renderer->create_buffer( BufferType::Constant_mask, ResourceUsageType::Dynamic, sizeof(LinesGPULocalConstants), nullptr, "line_renderer_cb" );
// Line segments buffers
lines_vb = renderer->create_buffer( BufferType::Vertex_mask, ResourceUsageType::Dynamic, sizeof( LineVertex ) * k_max_lines, nullptr, "lines_vb" );
lines_vb_2d = renderer->create_buffer( BufferType::Vertex_mask, ResourceUsageType::Dynamic, sizeof( LineVertex2D ) * k_max_lines, nullptr, "lines_vb_2d" );
current_line = current_line_2d = 0;
this->material = nullptr;
}
void DebugRenderer::shutdown( hydra::gfx::Renderer* renderer ) {
//renderer.destroy_material( material );
renderer->destroy_buffer( lines_vb );
renderer->destroy_buffer( lines_vb_2d );
renderer->destroy_buffer( lines_cb );
}
void DebugRenderer::reload( hydra::gfx::Renderer* renderer, hydra::ResourceManager* resource_manager ) {
renderer->destroy_material( material );
material = resource_manager->load<hydra::gfx::Material>( "line_material" );
}
void DebugRenderer::render( hydra::gfx::Renderer& renderer, hydra::gfx::CommandBuffer* gpu_commands, hydra::gfx::Camera& camera ) {
using namespace hydra::gfx;
if ( current_line || current_line_2d ) {
LinesGPULocalConstants* cb_data = ( LinesGPULocalConstants* )renderer.dynamic_allocate( lines_cb );
if ( cb_data ) {
cb_data->view_projection = camera.view_projection;
camera.get_projection_ortho_2d( cb_data->projection.raw );
cb_data->resolution = { renderer.width * 1.0f, renderer.height * 1.0f, 1.0f / renderer.width, 1.0f / renderer.height };
cb_data->line_width = 1.f;
}
if ( this->material == nullptr ) {
hprint( "DebugRenderer does not have assigned a material. Skipping rendering.\n" );
return;
}
}
u64 sort_key = 0;
if ( current_line ) {
const u32 mapping_size = sizeof( LineVertex ) * current_line;
LineVertex* vtx_dst = ( LineVertex* )renderer.map_buffer( lines_vb, 0, mapping_size );
if ( vtx_dst ) {
memcpy( vtx_dst, &s_line_buffer[ 0 ], mapping_size );
renderer.unmap_buffer( lines_vb );
}
MaterialPass& pass = material->passes[ 0 ];
gpu_commands->bind_pipeline( sort_key++, pass.pipeline );
gpu_commands->bind_vertex_buffer( sort_key++, lines_vb->handle, 0, 0 );
gpu_commands->bind_resource_list( sort_key++, &pass.resource_list, 1, nullptr, 0 );
// Draw using instancing and 6 vertices.
const uint32_t num_vertices = 6;
gpu_commands->draw( sort_key++, TopologyType::Triangle, 0, num_vertices, 0, current_line / 2 );
current_line = 0;
}
if ( current_line_2d ) {
const u32 mapping_size = sizeof( LineVertex2D ) * current_line;
LineVertex2D* vtx_dst = ( LineVertex2D* )renderer.map_buffer( lines_vb, 0, mapping_size );
if ( vtx_dst ) {
memcpy( vtx_dst, &s_line_buffer_2d[ 0 ], mapping_size );
}
MaterialPass& pass = material->passes[ 1 ];
gpu_commands->bind_pipeline( sort_key++, pass.pipeline );
gpu_commands->bind_vertex_buffer( sort_key++, lines_vb->handle, 0, 0 );
gpu_commands->bind_resource_list( sort_key++, &pass.resource_list, 1, nullptr, 0 );
// Draw using instancing and 6 vertices.
const uint32_t num_vertices = 6;
gpu_commands->draw( sort_key++, TopologyType::Triangle, 0, num_vertices, 0, current_line_2d / 2 );
current_line_2d = 0;
}
}
void DebugRenderer::line( const vec3s& from, const vec3s& to, hydra::Color color ) {
line( from, to, color, color );
}
void DebugRenderer::line( const vec3s& from, const vec3s& to, hydra::Color color0, hydra::Color color1 ) {
if ( current_line >= k_max_lines )
return;
s_line_buffer[ current_line++ ].set( from, color0 );
s_line_buffer[ current_line++ ].set( to, color1 );
}
void DebugRenderer::box( const vec3s& min, const vec3s max, hydra::Color color ) {
const float x0 = min.x;
const float y0 = min.y;
const float z0 = min.z;
const float x1 = max.x;
const float y1 = max.y;
const float z1 = max.z;
line( { x0, y0, z0 }, { x0, y1, z0 }, color, color );
line( { x0, y1, z0 }, { x1, y1, z0 }, color, color );
line( { x1, y1, z0 }, { x1, y0, z0 }, color, color );
line( { x1, y0, z0 }, { x0, y0, z0 }, color, color );
line( { x0, y0, z0 }, { x0, y0, z1 }, color, color );
line( { x0, y1, z0 }, { x0, y1, z1 }, color, color );
line( { x1, y1, z0 }, { x1, y1, z1 }, color, color );
line( { x1, y0, z0 }, { x1, y0, z1 }, color, color );
line( { x0, y0, z1 }, { x0, y1, z1 }, color, color );
line( { x0, y1, z1 }, { x1, y1, z1 }, color, color );
line( { x1, y1, z1 }, { x1, y0, z1 }, color, color );
line( { x1, y0, z1 }, { x0, y0, z1 }, color, color );
}
} // namespace gfx
} // namespace hydra
| 37.094118 | 159 | 0.606565 | JorenJoestar |
f7f87dc0a12162cb19956915ef45c3e62742b8b2 | 6,307 | cc | C++ | extern/glow/src/glow/data/TextureData.cc | rovedit/Fort-Candle | 445fb94852df56c279c71b95c820500e7fb33cf7 | [
"MIT"
] | null | null | null | extern/glow/src/glow/data/TextureData.cc | rovedit/Fort-Candle | 445fb94852df56c279c71b95c820500e7fb33cf7 | [
"MIT"
] | null | null | null | extern/glow/src/glow/data/TextureData.cc | rovedit/Fort-Candle | 445fb94852df56c279c71b95c820500e7fb33cf7 | [
"MIT"
] | null | null | null | #include "TextureData.hh"
#include "SurfaceData.hh"
#include <glow/common/log.hh>
#include <glow/common/profiling.hh>
#include <glow/common/str_utils.hh>
using namespace glow;
TextureData::LoadFromFileFunc TextureData::sLoadFunc = nullptr;
TextureData::TextureData() {}
void TextureData::addSurface(const SharedSurfaceData& surface) { mSurfaces.push_back(surface); }
SharedTextureData TextureData::createFromFile(const std::string& filename, ColorSpace colorSpace)
{
GLOW_ACTION();
auto ending = util::toLower(util::fileEndingOf(filename));
// try custom loader
if (sLoadFunc)
{
auto tex = sLoadFunc(filename, ending, colorSpace);
if (tex)
return tex;
}
// lodepng
if (ending == ".png")
return loadWithLodepng(filename, ending, colorSpace);
// stb
if (ending == ".png" || //
ending == ".jpg" || //
ending == ".jpeg" || //
ending == ".tga" || //
ending == ".bmp" || //
ending == ".psd" || //
ending == ".gif" || //
ending == ".hdr" || //
ending == ".pic" || //
ending == ".ppm" || //
ending == ".pgm")
return loadWithStb(filename, ending, colorSpace);
// try Qt
#ifdef GLOW_USE_QT
return loadWithQt(filename, ending, colorSpace);
#endif
error() << "file type of `" << filename << "' not recognized.";
return nullptr;
}
SharedTextureData TextureData::createFromRawPng(const unsigned char* rawData, size_t rawDataSize, ColorSpace colorSpace)
{
return loadWithLodepng(rawData, rawDataSize, colorSpace);
}
SharedTextureData TextureData::createFromFileCube(
const std::string& fpx, const std::string& fnx, const std::string& fpy, const std::string& fny, const std::string& fpz, const std::string& fnz, ColorSpace colorSpace)
{
GLOW_ACTION();
auto tpx = createFromFile(fpx, colorSpace);
auto tnx = createFromFile(fnx, colorSpace);
auto tpy = createFromFile(fpy, colorSpace);
auto tny = createFromFile(fny, colorSpace);
auto tpz = createFromFile(fpz, colorSpace);
auto tnz = createFromFile(fnz, colorSpace);
SharedTextureData ts[] = {tpx, tnx, tpy, tny, tpz, tnz};
for (auto i = 0; i < 6; ++i)
if (!ts[i])
return nullptr;
for (auto i = 1; i < 6; ++i)
if (ts[0]->getWidth() != ts[i]->getWidth() || ts[0]->getHeight() != ts[i]->getHeight())
{
std::string files[] = {fpx, fnx, fpy, fny, fpz, fnz};
error() << "CubeMaps require same size for every texture: ";
error() << " " << ts[0]->getWidth() << "x" << ts[0]->getHeight() << ", " << files[0];
error() << " " << ts[i]->getWidth() << "x" << ts[i]->getHeight() << ", " << files[i];
return nullptr;
}
auto tex = tpx;
tex->setTarget(GL_TEXTURE_CUBE_MAP);
for (auto const& s : tex->getSurfaces())
s->setTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
for (auto i = 1; i < 6; ++i)
for (auto const& s : ts[i]->getSurfaces())
{
s->setTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
tex->addSurface(s);
}
return tex;
}
SharedTextureData TextureData::createFromRawPngCube(const unsigned char* rpx,
size_t rpxs,
const unsigned char* rnx,
size_t rnxs,
const unsigned char* rpy,
size_t rpys,
const unsigned char* rny,
size_t rnys,
const unsigned char* rpz,
size_t rpzs,
const unsigned char* rnz,
size_t rnzs,
ColorSpace colorSpace)
{
GLOW_ACTION();
auto tpx = createFromRawPng(rpx, rpxs, colorSpace);
auto tnx = createFromRawPng(rnx, rnxs, colorSpace);
auto tpy = createFromRawPng(rpy, rpys, colorSpace);
auto tny = createFromRawPng(rny, rnys, colorSpace);
auto tpz = createFromRawPng(rpz, rpzs, colorSpace);
auto tnz = createFromRawPng(rnz, rnzs, colorSpace);
SharedTextureData ts[] = {tpx, tnx, tpy, tny, tpz, tnz};
for (auto i = 0; i < 6; ++i)
if (!ts[i])
return nullptr;
for (auto i = 1; i < 6; ++i)
if (ts[0]->getWidth() != ts[i]->getWidth() || ts[0]->getHeight() != ts[i]->getHeight())
{
error() << "CubeMaps require same size for every texture: ";
error() << " " << ts[0]->getWidth() << "x" << ts[0]->getHeight() << 0;
error() << " " << ts[i]->getWidth() << "x" << ts[i]->getHeight() << i;
return nullptr;
}
auto tex = tpx;
tex->setTarget(GL_TEXTURE_CUBE_MAP);
for (auto const& s : tex->getSurfaces())
s->setTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
for (auto i = 1; i < 6; ++i)
for (auto const& s : ts[i]->getSurfaces())
{
s->setTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
tex->addSurface(s);
}
return tex;
}
void TextureData::saveToFile(const std::string& filename, int quality)
{
GLOW_ACTION();
auto ending = util::toLower(util::fileEndingOf(filename));
// TODO: 3D texture
if (mDepth > 1)
{
warning() << "Texture has " << mDepth << " layers, only first one will be saved to " << filename;
}
// lodepng
if (ending == ".png")
{
saveWithLodepng(this, filename, ending);
return;
}
// stb
if (ending == ".tga" || //
ending == ".bmp" || //
ending == ".hdr")
{
saveWithStb(this, filename, ending);
return;
}
// try Qt
#ifdef GLOW_USE_QT
{
saveWithQt(this, filename, ending);
return;
}
#endif
error() << "file type of `" << filename << "' not recognized.";
return;
}
void TextureData::setLoadFunction(const TextureData::LoadFromFileFunc& func) { sLoadFunc = func; }
| 32.510309 | 170 | 0.526875 | rovedit |
f7fb115b479020ffcfe3b5a245ce14ac2fa31d00 | 1,735 | cpp | C++ | Recursion and Backtracking/Kpartition.cpp | Ankitlenka26/IP2021 | 99322c9c84a8a9c9178a505afbffdcebd312b059 | [
"MIT"
] | null | null | null | Recursion and Backtracking/Kpartition.cpp | Ankitlenka26/IP2021 | 99322c9c84a8a9c9178a505afbffdcebd312b059 | [
"MIT"
] | null | null | null | Recursion and Backtracking/Kpartition.cpp | Ankitlenka26/IP2021 | 99322c9c84a8a9c9178a505afbffdcebd312b059 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
using namespace std;
static int counter = 0;
void solution(int i, int n, int k, int cones, vector<vector<int>> &ans)
{
//write your code here
if (i > n)
{
// cout << "Hello" << endl;
if (cones == k)
{
counter++;
cout << counter << ". ";
for (const vector<int> &row : ans)
{
cout << "[";
for (int i = 0; i < row.size(); i++)
{
if (i == row.size() - 1)
{
cout << row[i];
}
else
{
cout << row[i] << ", ";
}
}
cout << "] ";
}
cout << endl;
}
return;
}
for (int j = 0; j < ans.size(); j++)
{
// cout << ans[j].size() << endl ;
if (ans[j].size() != 0)
{
// cout << "Already full set" << endl ;
ans[j].push_back(i);
solution(i + 1, n, k, cones, ans);
// since we hae not added any non empty sets;
ans[j].pop_back();
}
else
{
// cout << "Empty set" << endl;
ans[j].push_back(i);
solution(i + 1, n, k, cones + 1, ans);
ans[j].pop_back();
break;
}
}
}
int main()
{
int n, k;
cin >> n >> k;
vector<vector<int>> ans(k, vector<int>());
// for(int i=0 ; i<)
solution(1, n, k, 0, ans);
return 0;
}
/*
cones => count of non empty sets
1 => start of number
n => end of number
k => no of partition
*/ | 23.445946 | 71 | 0.358501 | Ankitlenka26 |
f7fb5fd609bee157b8671ec92c5644458c59ca62 | 4,913 | hpp | C++ | sparta/cache/LineData.hpp | debjyoti0891/map | abdae67964420d7d36255dcbf83e4240a1ef4295 | [
"MIT"
] | 44 | 2019-12-13T06:39:13.000Z | 2022-03-29T23:09:28.000Z | sparta/cache/LineData.hpp | debjyoti0891/map | abdae67964420d7d36255dcbf83e4240a1ef4295 | [
"MIT"
] | 222 | 2020-01-14T21:58:56.000Z | 2022-03-31T20:05:12.000Z | sparta/cache/LineData.hpp | debjyoti0891/map | abdae67964420d7d36255dcbf83e4240a1ef4295 | [
"MIT"
] | 19 | 2020-01-03T19:03:22.000Z | 2022-01-09T08:36:20.000Z |
#pragma once
#include <cstring>
#include "sparta/utils/ByteOrder.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "cache/BasicCacheItem.hpp"
namespace sparta
{
namespace cache
{
class LineData : public BasicCacheItem
{
public:
// Constructor
LineData(uint64_t line_size) :
BasicCacheItem(),
line_sz_(line_size),
valid_(false),
modified_(false),
exclusive_(false),
shared_(false),
data_ptr_(new uint8_t[line_size]),
data_(data_ptr_.get())
{ }
// Copy constructor (for deep copy)
LineData(const LineData &rhs) :
BasicCacheItem(rhs),
line_sz_(rhs.line_sz_),
valid_(rhs.valid_),
modified_(rhs.modified_),
exclusive_(rhs.exclusive_),
shared_(rhs.shared_),
data_ptr_(new uint8_t[line_sz_]),
data_(data_ptr_.get())
{
memcpy(data_,rhs.data_,line_sz_);
}
void reset(uint64_t addr) {
setValid ( true );
setAddr ( addr );
setModified ( false );
setExclusive( true );
setShared ( false );
}
// Assigment operator (for deep copy)
LineData &operator=(const LineData &rhs)
{
if (&rhs != this) {
BasicCacheItem::operator=(rhs);
line_sz_ = rhs.line_sz_;
valid_ = rhs.valid_;
modified_ = rhs.modified_;
exclusive_ = rhs.exclusive_;
shared_ = rhs.shared_;
data_ptr_.reset(new uint8_t[line_sz_]);
data_ = data_ptr_.get();
memcpy(data_,rhs.data_,line_sz_);
}
return *this;
}
// Coherency states
// - Coherency states (MESI) are not known or managed by cache library
// - isValid() is required by the library
void setValid(bool v) { valid_ = v; }
void setModified(bool m) { modified_ = m; }
void setExclusive(bool e) { exclusive_ = e; }
void setShared(bool s) { shared_ = s; }
bool isValid() const { return valid_; }
bool isModified() const { return modified_; }
bool isExclusive() const { return exclusive_; }
bool isShared() const { return shared_; }
uint64_t getLineSize() const { return line_sz_; }
uint8_t *getDataPtr() { return data_; }
const uint8_t *getDataPtr() const { return data_; }
// The following templatized read & write methods were copied from
// ArchData.h. The intention is that there's a common interface
// to LineData as to all memory object in the simulator. At this point
// implementation details are TBD
template <typename T, ByteOrder BO>
T read(uint32_t offset, uint32_t idx=0) const {
uint32_t loc = offset + (idx*sizeof(T));
sparta_assert(loc + sizeof(T) <= line_sz_);
const uint8_t* d = data_ + loc;
T val = *reinterpret_cast<const T*>(d);
return reorder<T,BO>(val);
}
// Copied from ArchData.h. See comments on read above.
template <typename T, ByteOrder BO>
void write(uint32_t offset, const T& t, uint32_t idx=0) {
uint32_t loc = offset + (idx*sizeof(T));
sparta_assert(loc + sizeof(T) <= line_sz_);
uint8_t* d = data_ + loc;
T& val = *reinterpret_cast<T*>(d);
val = reorder<T,BO>(t);
}
bool read(uint64_t offset,
uint32_t size,
uint8_t *buf) const
{
sparta_assert( (offset + size) <= line_sz_ );
memcpy(buf, &data_[offset], size);
return true;
}
bool write(uint64_t offset,
uint32_t size,
const uint8_t *buf )
{
sparta_assert( (offset + size) <= line_sz_ );
memcpy(&data_[offset], buf, size);
return true;
}
private:
uint64_t line_sz_;
bool valid_;
bool modified_;
bool exclusive_;
bool shared_;
std::unique_ptr<uint8_t[]> data_ptr_;
uint8_t * data_ = nullptr;
}; // class LineData
}; // namespace cache
}; // namespace sparta
| 32.753333 | 83 | 0.483004 | debjyoti0891 |
f7fca7f0a1ab5371c77521df02499fe293640447 | 1,435 | hpp | C++ | include/MeshEditor/Cube.hpp | THOSE-EYES/MeshEditor | 6a58460a3ddfeba5d372aa92cd120b0c2a108c35 | [
"Apache-2.0"
] | null | null | null | include/MeshEditor/Cube.hpp | THOSE-EYES/MeshEditor | 6a58460a3ddfeba5d372aa92cd120b0c2a108c35 | [
"Apache-2.0"
] | null | null | null | include/MeshEditor/Cube.hpp | THOSE-EYES/MeshEditor | 6a58460a3ddfeba5d372aa92cd120b0c2a108c35 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2018 Illia Shvarov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "Command.hpp"
/**
* Constants
*/
#define MIN_ARGS 3
/**
* A command to create a cube in STL format
*/
class Cube : public Command {
public:
/**
* Getting command's title
* @return title
*/
const std::string getName() const override;
/**
* Start execution
* @param args arguments for the command
* @return error code or 0
*/
uint8_t execute(const map<string, string>&) override;
protected:
int length; // Length of a side
Coordinates origin; // Origin of the cube
string filepath; // File to save the cube
/**
* Parsing the arguments
* @param args the arguments
* @return error code or 0
*/
uint8_t parse(const map<string, string>&);
/**
* Create a shape of a cube out of vertexes
* @return a cube as an array of triangles
*/
const Triangles* createTriangles();
}; | 23.916667 | 75 | 0.69547 | THOSE-EYES |
f7fd34a2d2b297a07b9f4de7d7527453d94707e7 | 3,692 | cpp | C++ | Engine/Source/ComponentManager.cpp | AdamSzentesiGrip/MiniECS | c938b5e90746c06f9a4e8ca8e1c2d3e8bf3c3faf | [
"Unlicense"
] | null | null | null | Engine/Source/ComponentManager.cpp | AdamSzentesiGrip/MiniECS | c938b5e90746c06f9a4e8ca8e1c2d3e8bf3c3faf | [
"Unlicense"
] | null | null | null | Engine/Source/ComponentManager.cpp | AdamSzentesiGrip/MiniECS | c938b5e90746c06f9a4e8ca8e1c2d3e8bf3c3faf | [
"Unlicense"
] | null | null | null | #include "../Include/ComponentManager.h"
namespace Mini
{
ComponentManager::ComponentManager()
{
_ComponentIDRegister = new std::map<size_t, int_componentID>();
_ComponentBuffers = new std::vector<ComponentBufferBase*>();
}
ComponentManager::~ComponentManager()
{
delete _ComponentIDRegister;
delete _ComponentBuffers;
}
bool ComponentManager::IsRegistered(size_t hashCode)
{
return (_ComponentIDRegister->count(hashCode) > 0);
}
void ComponentManager::RegisterComponentType(ComponentBufferBase* componentBuffer)
{
int_componentID componentID = componentBuffer->GetComponentID();
size_t componentHashCode = componentBuffer->GetComponentHashCode();
const char* componentName = componentBuffer->GetComponentName();
LOG("REG COMPONENT " << static_cast<uint32_t>(componentID) << ": " << componentName);
_ComponentIDRegister->insert({ componentHashCode, componentID });
_ComponentBuffers->push_back(componentBuffer);
return;
}
void ComponentManager::AddComponent(EntityData* entityData, ComponentBase& component, int_componentID componentID)
{
component._EntityData = entityData;
if (AddComponentKey(entityData, componentID))
{
LOG("ADD + COMPONENT TO ENTITY " << (int)entityData->EntityID << ": " << GetComponentTypeName(componentID));
entityData->ComponentIndices[componentID] = (*_ComponentBuffers)[componentID]->AddComponent(component);
}
else
{
LOG("UPD COMPONENT ON ENTITY " << (int)entityData->EntityID << ": " << GetComponentTypeName(componentID));
(*_ComponentBuffers)[componentID]->UpdateComponent(entityData->ComponentIndices[componentID], component);
}
}
ComponentBase* ComponentManager::GetComponent(EntityData* entityData, int_componentID componentID)
{
if (!HasComponent(entityData, componentID)) return nullptr;
LOG("GET < COMPONENT FROM ENTITY " << (int)entityData->EntityID << ": " << GetComponentTypeName(componentID));
return (*_ComponentBuffers)[componentID]->GetComponent(entityData->ComponentIndices[componentID]);
}
int_entityID ComponentManager::RemoveComponent(size_t index, int_componentID componentID)
{
LOG("REM - COMPONENT FROM ENTITY " << (int)index << ": " << GetComponentTypeName(componentID));
return (*_ComponentBuffers)[componentID]->RemoveComponent(index);
}
int_componentID ComponentManager::GetComponentID(size_t componentHashCode)
{
return _ComponentIDRegister->at(componentHashCode);
}
componentKey ComponentManager::GetComponentKey(int_componentID componentID)
{
componentKey componentKey = 1;
componentKey <<= componentID;
return componentKey;
}
bool ComponentManager::HasComponentKey(EntityData* entityData, componentKey componentKey)
{
return ((entityData->EntityComponentKey & componentKey) != 0);
}
bool ComponentManager::HasComponent(EntityData* entityData, int_componentID componentID)
{
return HasComponentKey(entityData, GetComponentKey(componentID));
}
bool ComponentManager::AddComponentKey(EntityData* entityData, int_componentID componentID)
{
componentKey componentKey = GetComponentKey(componentID);
if(HasComponentKey(entityData, componentKey))
{
return false;
}
entityData->EntityComponentKey |= componentKey;
return true;
}
bool ComponentManager::RemoveComponentKey(EntityData* entityData, int_componentID componentID)
{
componentKey componentKey = GetComponentKey(componentID);
if (!HasComponentKey(entityData, componentKey))
{
return false;
}
entityData->EntityComponentKey &= ~componentKey;
return true;
}
const char* ComponentManager:: GetComponentTypeName(int_componentID componentID)
{
return (*_ComponentBuffers)[componentID]->GetComponentName();
}
} | 29.536 | 115 | 0.765439 | AdamSzentesiGrip |
f7fe544645e6a9391e8ecbec67334181773576bf | 29,919 | cpp | C++ | applis/OLD-MICMAC-OLD/cOrientationGrille.cpp | kikislater/micmac | 3009dbdad62b3ad906ec882b74b85a3db86ca755 | [
"CECILL-B"
] | 451 | 2016-11-25T09:40:28.000Z | 2022-03-30T04:20:42.000Z | applis/OLD-MICMAC-OLD/cOrientationGrille.cpp | kikislater/micmac | 3009dbdad62b3ad906ec882b74b85a3db86ca755 | [
"CECILL-B"
] | 143 | 2016-11-25T20:35:57.000Z | 2022-03-01T11:58:02.000Z | applis/OLD-MICMAC-OLD/cOrientationGrille.cpp | kikislater/micmac | 3009dbdad62b3ad906ec882b74b85a3db86ca755 | [
"CECILL-B"
] | 139 | 2016-12-02T10:26:21.000Z | 2022-03-10T19:40:29.000Z | /*Header-MicMac-eLiSe-25/06/2007
MicMac : Multi Image Correspondances par Methodes Automatiques de Correlation
eLiSe : ELements of an Image Software Environnement
www.micmac.ign.fr
Copyright : Institut Geographique National
Author : Marc Pierrot Deseilligny
Contributors : Gregoire Maillet, Didier Boldo.
[1] M. Pierrot-Deseilligny, N. Paparoditis.
"A multiresolution and optimization-based image matching approach:
An application to surface reconstruction from SPOT5-HRS stereo imagery."
In IAPRS vol XXXVI-1/W41 in ISPRS Workshop On Topographic Mapping From Space
(With Special Emphasis on Small Satellites), Ankara, Turquie, 02-2006.
[2] M. Pierrot-Deseilligny, "MicMac, un lociel de mise en correspondance
d'images, adapte au contexte geograhique" to appears in
Bulletin d'information de l'Institut Geographique National, 2007.
Francais :
MicMac est un logiciel de mise en correspondance d'image adapte
au contexte de recherche en information geographique. Il s'appuie sur
la bibliotheque de manipulation d'image eLiSe. Il est distibue sous la
licences Cecill-B. Voir en bas de fichier et http://www.cecill.info.
English :
MicMac is an open source software specialized in image matching
for research in geographic information. MicMac is built on the
eLiSe image library. MicMac is governed by the "Cecill-B licence".
See below and http://www.cecill.info.
Header-MicMac-eLiSe-25/06/2007*/
#include "general/all.h"
#include <iostream>
#include <vector>
#include <string>
#include <complex>
#include <fstream>
#include <iomanip>
#include <list>
#include <stdexcept>
#include "cModuleOrientation.h"
#include "cOrientationGrille.h"
#ifdef __AVEC_XERCES__
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
XERCES_CPP_NAMESPACE_USE
#else
#ifdef VERSION
#undef VERSION
#endif
#include "private/files.h"
#endif
// variable static de la classe
std::map<std::string, OrientationGrille*> OrientationGrille::dico_camera;
void OrientationGrille::WriteBinary(std::string const &nom)const
{
std::cout << "OrientationGrille::WriteBinary"<<std::endl;
std::ofstream fic(nom.c_str(),ios::binary);
double pt2dD[2];
int pt2dI[2];
pt2dD[0]=Image2Obj_ULC.real();
pt2dD[1]=Image2Obj_ULC.imag();
fic.write((const char*)&pt2dD,2*sizeof(double));
pt2dD[0]=Image2Obj_Pas.real();
pt2dD[1]=Image2Obj_Pas.imag();
fic.write((const char*)&pt2dD,2*sizeof(double));
pt2dI[0]=Image2Obj_Taille.real();
pt2dI[1]=Image2Obj_Taille.imag();
fic.write((const char*)&pt2dI,2*sizeof(int));
fic.write((const char*)&Image2Obj_TailleZ,sizeof(int));
int NbCouches = (int) Image2Obj.size();
fic.write((const char*)&NbCouches,sizeof(int));
size_t Taille = Image2Obj_Taille.real()*Image2Obj_Taille.imag()*Image2Obj_TailleZ*sizeof(double);
for(int i=0;i<NbCouches;++i)
{
std::vector<double> const &layer=Image2Obj[i];
fic.write((const char*)&Image2Obj_Value[i],sizeof(double));
fic.write((const char*)&(layer[0]),(unsigned int) Taille);
}
pt2dD[0]=Obj2Image_ULC.real();
pt2dD[1]=Obj2Image_ULC.imag();
fic.write((const char*)&pt2dD,2*sizeof(double));
pt2dD[0]=Obj2Image_Pas.real();
pt2dD[1]=Obj2Image_Pas.imag();
fic.write((const char*)&pt2dD,2*sizeof(double));
pt2dI[0]=Obj2Image_Taille.real();
pt2dI[1]=Obj2Image_Taille.imag();
fic.write((const char*)&pt2dI,2*sizeof(int));
fic.write((const char*)&Obj2Image_TailleZ,sizeof(int));
NbCouches = (int) Obj2Image.size();
fic.write((const char*)&NbCouches,sizeof(int));
Taille = Obj2Image_Taille.real()*Obj2Image_Taille.imag()*Obj2Image_TailleZ*sizeof(double);
for(int i=0;i<NbCouches;++i)
{
std::vector<double> const &layer=Obj2Image[i];
fic.write((const char*)&Obj2Image_Value[i],sizeof(double));
fic.write((const char*)&(layer[0]),(unsigned int) Taille);
}
fic.close();
}
void OrientationGrille::InitBinary(std::string const &nom)
{
std::cout << "OrientationGrille::InitBinary"<<std::endl;
camera=NULL;
std::ifstream fic(nom.c_str(),ios::binary);
double pt2dD[2];
int pt2dI[2];
fic.read((char*)&pt2dD,2*sizeof(double));
Image2Obj_ULC=std::complex<double>(pt2dD[0],pt2dD[1]);
fic.read((char*)&pt2dD,2*sizeof(double));
Image2Obj_Pas=std::complex<double>(pt2dD[0],pt2dD[1]);
fic.read((char*)&pt2dI,2*sizeof(int));
Image2Obj_Taille=std::complex<int>(pt2dI[0],pt2dI[1]);
fic.read((char*)&Image2Obj_TailleZ,sizeof(int));
int NbCouches;
fic.read((char*)&NbCouches,sizeof(int));
Image2Obj.resize(NbCouches);
Image2Obj_Value.resize(NbCouches);
size_t Taille = Image2Obj_Taille.real()*Image2Obj_Taille.imag()*Image2Obj_TailleZ*sizeof(double);
for(int i=0;i<NbCouches;++i)
{
std::vector<double> &layer=Image2Obj[i];
layer.resize(Taille);
fic.read((char*)&Image2Obj_Value[i],sizeof(double));
fic.read((char*)&(layer[0]),(unsigned int) Taille);
}
fic.read((char*)&pt2dD,2*sizeof(double));
Obj2Image_ULC=std::complex<double>(pt2dD[0],pt2dD[1]);
fic.read((char*)&pt2dD,2*sizeof(double));
Obj2Image_Pas=std::complex<double>(pt2dD[0],pt2dD[1]);
fic.read((char*)&pt2dI,2*sizeof(int));
Obj2Image_Taille=std::complex<int>(pt2dI[0],pt2dI[1]);
fic.read((char*)&Obj2Image_TailleZ,sizeof(int));
fic.read((char*)&NbCouches,sizeof(int));
Obj2Image.resize(NbCouches);
Obj2Image_Value.resize(NbCouches);
Taille = Obj2Image_Taille.real()*Obj2Image_Taille.imag()*Obj2Image_TailleZ*sizeof(double);
for(int i=0;i<NbCouches;++i)
{
std::vector<double> &layer=Obj2Image[i];
layer.resize(Taille);
fic.read((char*)&Obj2Image_Value[i],sizeof(double));
fic.read((char*)&(layer[0]),(unsigned int) Taille);
}
fic.close();
}
OrientationGrille::OrientationGrille(std::string const &nom):ModuleOrientation(nom)
{
Image2Obj_Taille = std::complex<int>(0,0);
Image2Obj_TailleZ = 0;
Obj2Image_Taille = std::complex<int>(0,0);
Obj2Image_TailleZ = 0;
camera = NULL;
bool isXML = true;
{
std::ifstream fic(nom.c_str());
if (!fic.good())
{
std::cout << "Fichier : "<<nom<<" non valide"<<std::endl;
throw std::logic_error("[OrientationGrille::OrientationGrille] : Erreur dans la lecture du fichier");
}
char c;
fic >> c;
isXML = (c == '<');
}
if (isXML)
InitXML(nom);
else
InitBinary(nom);
if (Obj2Image.size()==0)
{
std::cout << "Grille inverse non disponible" << std::endl;
// exit (-1);
// TRAITEMENT PROVISOIRE MPD A CORRIGER
/*
MicMacErreur
(
eErrGrilleInverseNonDisponible,
"La grille de contient pas de grille inverse",
""
);
*/
//
throw std::logic_error("[OrientationGrille::OrientationGrille] : Grille inverse non disponible");
}
PrecisionRetour = GetResolMoyenne()*0.1;
}
void OrientationGrille::InitXML(std::string const &nom)
{
std::cout << "Debut de lecture du ficier XML : " << nom << std::endl;
std::string nomCamera("");
#ifdef __AVEC_XERCES__
try {
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch) {
char* message = XMLString::transcode(toCatch.getMessage());
std::cout << "Error during initialization! :\n"
<< message << "\n";
XMLString::release(&message);
return;
}
XercesDOMParser* parser = new XercesDOMParser();
parser->setValidationScheme(XercesDOMParser::Val_Always); // optional
parser->setDoNamespaces(true); // optional
ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
parser->setErrorHandler(errHandler);
try {
parser->parse(nom.c_str());
}
catch (const XMLException& toCatch) {
char* message = XMLString::transcode(toCatch.getMessage());
std::cout << "Exception message is: \n"
<< message << "\n";
XMLString::release(&message);
return;
}
catch (const DOMException& toCatch) {
char* message = XMLString::transcode(toCatch.msg);
std::cout << "Exception message is: \n"
<< message << "\n";
XMLString::release(&message);
return;
}
catch (...) {
std::cout << "Unexpected Exception \n" ;
return;
}
DOMNode* doc = parser->getDocument();
DOMNode* n = doc->getFirstChild();
if (n)
n=n->getFirstChild();
while(n)
{
if (!XMLString::compareString(n->getNodeName(),XMLString::transcode("trans_coord")))
{
DOMNode* sn = n->getFirstChild();
while(sn)
{
if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("sys_coord")))
{
DOMNamedNodeMap* att = sn->getAttributes();
if (!att)
continue;
if (XMLString::compareString(att->getNamedItem(XMLString::transcode("name"))->getNodeValue(),XMLString::transcode("sys1")))
continue;
DOMNode* sn2 = sn->getFirstChild();
while(sn2)
{
if (!XMLString::compareString(sn2->getNodeName(),XMLString::transcode("sys_coord_plani")))
{
DOMNode* sn3 = sn2->getFirstChild();
while(sn3)
{
if (!XMLString::compareString(sn3->getNodeName(),XMLString::transcode("sub_code")))
{
nomCamera=std::string(XMLString::transcode(sn3->getFirstChild()->getNodeValue()));
sn3=NULL;
}
else sn3=sn3->getNextSibling();
}
sn2 = NULL;
}
else sn2=sn2->getNextSibling();
}
}
sn=sn->getNextSibling();
}
}
else if (!XMLString::compareString(n->getNodeName(),XMLString::transcode("multi_grid")))
{
std::cout << "ICI" << std::endl;
DOMNamedNodeMap* att = n->getAttributes();
if (!att)
continue;
std::complex<double> *Pas;
std::complex<int> *Taille;
std::complex<double> *ULC;
std::vector<std::vector<double> > *Grille;
std::vector<double> *Value;
int *TZ;
if (!XMLString::compareString(att->getNamedItem(XMLString::transcode("name"))->getNodeValue(),XMLString::transcode("2-1")))
{
std::cout << "Gri 2->1"<<std::endl;
Pas = &Obj2Image_Pas;
Taille = &Obj2Image_Taille;
TZ = &Obj2Image_TailleZ;
ULC = &Obj2Image_ULC;
Grille = &Obj2Image;
Value = &Obj2Image_Value;
}
else
{
std::cout << "Gri 1->2"<<std::endl;
Pas = &Image2Obj_Pas;
Taille = &Image2Obj_Taille;
TZ = &Image2Obj_TailleZ;
ULC = &Image2Obj_ULC;
Grille = &Image2Obj;
Value = &Image2Obj_Value;
}
DOMNode* sn = n->getFirstChild();
while(sn)
{
if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("columns_interval")))
{
(*Pas)=std::complex<double>(atof(XMLString::transcode(sn->getFirstChild()->getNodeValue())),Pas->imag());
}
else if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("rows_interval")))
{
(*Pas)=std::complex<double>(Pas->real(),atof(XMLString::transcode(sn->getFirstChild()->getNodeValue())));
}
if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("columns_number")))
{
(*Taille)=std::complex<int>(atoi(XMLString::transcode(sn->getFirstChild()->getNodeValue())),Taille->imag());
}
else if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("rows_number")))
{
(*Taille)=std::complex<int>(Taille->real(),atoi(XMLString::transcode(sn->getFirstChild()->getNodeValue())));
}
else if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("components_number")))
{
(*TZ)=atoi(XMLString::transcode(sn->getFirstChild()->getNodeValue()));
}
else if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("upper_left")))
{
std::istringstream buffer(XMLString::transcode(sn->getFirstChild()->getNodeValue()));
double ULCx,ULCy;
buffer >> ULCx >> ULCy;
(*ULC) = std::complex<double>(ULCx,ULCy);
}
else if (!XMLString::compareString(sn->getNodeName(),XMLString::transcode("layer")))
{
//DOMNamedNodeMap* snatt = sn->getAttributes();
double value = atof(XMLString::transcode(sn->getAttributes()->getNamedItem(XMLString::transcode("value"))->getNodeValue()));
std::cout << "value : "<<value<<std::endl;
Value->push_back(value);
Grille->push_back(std::vector<double>());
std::vector<double> & grille = (*Grille)[Grille->size()-1];
std::istringstream buffer(XMLString::transcode(sn->getFirstChild()->getNodeValue()));
int T = Taille->real()*Taille->imag()*(*TZ);
grille.resize(T);
for(int i=0;i<T;++i)
buffer >> grille[i];
}
sn=sn->getNextSibling();
}
}
n = n->getNextSibling();
}
delete parser;
delete errHandler;
#else
cElXMLTree tree(nom);
// Recherche de la camera eventuelle
{
std::list<cElXMLTree*> noeuds=tree.GetAll(std::string("sys_coord_plani"));
std::list<cElXMLTree*>::iterator it_grid,fin_grid=noeuds.end();
for(it_grid=noeuds.begin();it_grid!=fin_grid;++it_grid)
{
std::string name = (*it_grid)->ValAttr("name");
if (name==std::string("sys1"))
{
cElXMLTree* pt = (*it_grid)->GetUnique("sys_coord_plani");
if (!pt->GetUnique("sub_code")->IsVide())
{
nomCamera=pt->GetUnique("sub_code")->GetUniqueVal();
}
}
}
}
// Lecture des grilles
{
std::list<cElXMLTree*> noeuds=tree.GetAll(std::string("multi_grid"));
std::list<cElXMLTree*>::iterator it_grid,fin_grid=noeuds.end();
for(it_grid=noeuds.begin();it_grid!=fin_grid;++it_grid)
{
std::string name = (*it_grid)->ValAttr("name");
std::cout << "MULTI_GRID : "<<name<<std::endl;
std::complex<double> *Pas;
std::complex<int> *Taille;
std::complex<double> *ULC;
std::vector<std::vector<double> > *Grille;
std::vector<double> *Value;
int *TZ;
if (name==std::string("2-1"))
{
std::cout << "Gri 2->1"<<std::endl;
Pas = &Obj2Image_Pas;
Taille = &Obj2Image_Taille;
TZ = &Obj2Image_TailleZ;
ULC = &Obj2Image_ULC;
Grille = &Obj2Image;
Value = &Obj2Image_Value;
}
else
{
std::cout << "Gri 1->2"<<std::endl;
Pas = &Image2Obj_Pas;
Taille = &Image2Obj_Taille;
TZ = &Image2Obj_TailleZ;
ULC = &Image2Obj_ULC;
Grille = &Image2Obj;
Value = &Image2Obj_Value;
}
(*Pas)= std::complex<double>((*it_grid)->GetUniqueValDouble("columns_interval"),(*it_grid)->GetUniqueValDouble("rows_interval"));
(*Taille) = std::complex<int>((*it_grid)->GetUniqueValInt("columns_number"),(*it_grid)->GetUniqueValInt("rows_number"));
(*TZ) = (*it_grid)->GetUniqueValInt("components_number");
//std::cout << "Taille : "<<(*Taille)<<std::endl;
//std::cout << "Pas : "<<(*Pas)<<std::endl;
// Lecture du ULCorner
{
double ULCx,ULCy;
std::istringstream buffer((*it_grid)->GetUnique("upper_left")->GetUniqueVal());
buffer >> ULCx >> ULCy;
(*ULC)=std::complex<double>(ULCx,ULCy);
}
//std::cout << "ULC : "<<(*ULC)<<std::endl;
// Lecuture des layers
{
std::list<cElXMLTree*> layers=(*it_grid)->GetAll("layer");
std::list<cElXMLTree*>::iterator it,fin=layers.end();
for(it=layers.begin();it!=fin;++it)
{
double value=atof((*it)->ValAttr("value").c_str());
std::istringstream buffer((*it)->Contenu());
int T = Taille->real()*Taille->imag()*(*TZ);
Grille->push_back(std::vector<double>());
Value->push_back(value);
std::vector<double> &layer=(*Grille)[Grille->size()-1];
layer.resize(T);
for(int c=0;c<T;++c)
{
buffer >> layer[c];
}
}
}
std::cout << "Nombre de couches : "<< (unsigned int) Value->size()<<std::endl;
}
}
#endif
std::cout << "Camera : "<<nomCamera<<std::endl;
if ((nomCamera.length()>0)&&(nomCamera!=std::string("*")))
{
std::map<std::string, OrientationGrille*>::iterator it=dico_camera.find(nomCamera);
if (it==dico_camera.end())
{
// recuperation du chemin de fichier
std::string path;
{
int placeSlash = -1;
for(int l=nom.size()-1;(l>=0)&&(placeSlash==-1);--l)
{
if ( ( nom[l]=='/' )||( nom[l]=='\\' ) )
{
placeSlash = l;
}
}
path = std::string("");
if (placeSlash!=-1)
{
path.assign(nom.begin(),nom.begin()+placeSlash+1);
}
}
std::string nomFichierCamera = path+nomCamera+std::string(".gri");
std::cout << "Chargement d'un nouveau fichier de camera : "<<nomFichierCamera<<std::endl;
camera = new OrientationGrille(nomFichierCamera);
dico_camera.insert(std::pair<std::string,OrientationGrille*>(nomCamera,camera));
}
else
{
std::cout << "Utilisation d'une camera deja chargee"<<std::endl;
camera = (*it).second;
}
}
std::cout << "Fin du Chargement" << std::endl;
}
void OrientationGrille::ImageAndPx2Obj(double c, double l, const double *aPx,
double &x, double &y)const
{
std::complex<double> position_grille;
// Si besoin on corrige la distorsion
if (camera)
{
double c_sans_distorsion,l_sans_distorsion = l;
camera->ImageAndPx2Obj(c,l,aPx,c_sans_distorsion,l_sans_distorsion);
// Position dans la grille
position_grille = std::complex<double>((c_sans_distorsion-Image2Obj_ULC.real())/Image2Obj_Pas.real(),
(Image2Obj_ULC.imag()-l_sans_distorsion)/Image2Obj_Pas.imag());
}
else
{
// Position dans la grille
position_grille = std::complex<double>((c-Image2Obj_ULC.real())/Image2Obj_Pas.real(),
(Image2Obj_ULC.imag()-l)/Image2Obj_Pas.imag());
}
// Si on n'a qu'une couche
if (Image2Obj_Value.size() == 1)
{
std::complex<double> P = interpolation(position_grille,Image2Obj[0],Image2Obj_Taille,Image2Obj_TailleZ);
x = P.real();
y = P.imag();
}
else
{
// Recherche des deux niveaux les plus proches
int l1=-1;
double d1=0.;
int l2=-1;
double d2=0.;
for(size_t id=0;id<Image2Obj_Value.size();++id)
{
double d=aPx[0]-Image2Obj_Value[id];
if (l1==-1)
{
l1 = (int) id;
d1 = d;
}
else if (std::abs(d)<std::abs(d1))
{
l2 = l1;
d2 = -d1;
l1 = (int) id;
d1 = d;
}
else if ((l2==-1)||(std::abs(d)<std::abs(d2)))
{
l2 = (int) id;
d2 = -d;
}
}
std::complex<double> P1 = interpolation(position_grille,Image2Obj[l1],Image2Obj_Taille,Image2Obj_TailleZ);
std::complex<double> P2 = interpolation(position_grille,Image2Obj[l2],Image2Obj_Taille,Image2Obj_TailleZ);
x = (P1.real()*d2+P2.real()*d1)/(d1+d2);
y = (P1.imag()*d2+P2.imag()*d1)/(d1+d2);
}
}
void OrientationGrille::Objet2ImageInit(double x, double y, const double *aPx,
double &c, double &l)const
{
// On verifie que la grille est disponible
if (Obj2Image.size()==0)
{
std::cout << "Grille inverse non disponible" << std::endl;
throw std::logic_error("[OrientationGrille::Objet2ImageInit] : Grille inverse non disponible");
return;
}
// Position dans la grille
std::complex<double> position_grille((x-Obj2Image_ULC.real())/Obj2Image_Pas.real(),
(Obj2Image_ULC.imag()-y)/Obj2Image_Pas.imag());
// Si il n'y a qu'un seul niveau
if (Obj2Image_Value.size()==1)
{
std::complex<double> P = interpolation(position_grille,Obj2Image[0],Obj2Image_Taille,Obj2Image_TailleZ);
c = P.real();
l = P.imag();
}
else
{
// Recherche des deux niveaux les plus proches
int l1=-1;
double d1=0.;
int l2=-1;
double d2=0.;
for(size_t id=0;id<Obj2Image_Value.size();++id)
{
double d=aPx[0]-Obj2Image_Value[id];
if (l1==-1)
{
l1 = (int) id;
d1 = d;
}
else if (std::abs(d)<std::abs(d1))
{
l2 = l1;
d2 = -d1;
l1 = (int) id;
d1 = d;
}
else if ((l2==-1)||(std::abs(d)<std::abs(d2)))
{
l2 = (int) id;
d2 = -d;
}
}
std::complex<double> P1 = interpolation(position_grille,Obj2Image[l1],Obj2Image_Taille,Obj2Image_TailleZ);
std::complex<double> P2 = interpolation(position_grille,Obj2Image[l2],Obj2Image_Taille,Obj2Image_TailleZ);
c = (P1.real()*d2+P2.real()*d1)/(d1+d2);
l = (P1.imag()*d2+P2.imag()*d1)/(d1+d2);
}
// Si besoin on applique la correction de distorsion
if (camera)
{
// transfo de coord sans distorsion vers des coord avec prise en compte de la distorsion
double c_sans_disto = c;
double l_sans_disto = l;
camera->Objet2ImageInit(c_sans_disto,l_sans_disto,aPx,c,l);
}
bool verbose = false;
double Xretour,Yretour;
ImageAndPx2Obj(c,l,aPx,Xretour,Yretour);
if (verbose) std::cout << "Point Retour : "<<Xretour<<" "<<Yretour<<std::endl;
double Err = sqrt((x-Xretour)*(x-Xretour)+(y-Yretour)*(y-Yretour));
if (verbose) std::cout << "Err = "<<Err<<" / "<<PrecisionRetour<<std::endl;
int NbEtape = 0;
while((Err>PrecisionRetour)&&(NbEtape<10))
{
if (verbose) std::cout << "NbEtape : "<<NbEtape<<std::endl;
++NbEtape;
double X1,Y1,X2,Y2;
ImageAndPx2Obj(c+1,l,aPx,X1,Y1);
ImageAndPx2Obj(c,l+1,aPx,X2,Y2);
double dX1,dY1,dX2,dY2;
dX1 = X1-Xretour;dY1 = Y1-Yretour;
dX2 = X2-Xretour;dY2 = Y2-Yretour;
double N = sqrt(dX1*dX1+dY1*dY1);
if (N!=0.)
{
double dc = (dX1*(Xretour-x)+dY1*(Yretour-y))/N/N;
double dl = (dX2*(Xretour-x)+dY2*(Yretour-y))/N/N;
c=c-dc;
l=l-dl;
ImageAndPx2Obj(c,l,aPx,Xretour,Yretour);
if (verbose) std::cout << "Nouveau retour : "<<Xretour<<" "<<Yretour<<std::endl;
Err = sqrt((x-Xretour)*(x-Xretour)+(y-Yretour)*(y-Yretour));
if (verbose) std::cout << "Nouvelle Err = "<<Err<<std::endl;
}
else Err = 0.;
}
}
double OrientationGrille::GetResolMoyenne() const
{
if (Image2Obj_Taille.real()<2)
return 1.;
// Estimation de la resolution au centre de la grille
// Pos : la position du centre de l'image (de la Grille)
int pos = Image2Obj_Taille.real()/2*Image2Obj_Taille.imag()/2;
// Vect : le vecteur Obj entre deux points voisins (sur une ligne) au centre de la grille (les points : pos et (pos+1))
std::complex<double> Vect(Image2Obj[0][2*(pos+1) ]-Image2Obj[0][2*pos ],
Image2Obj[0][2*(pos+1)+1]-Image2Obj[0][2*pos +1]);
// On divise la norme de ce vecteur (distance en geometrie Obj) par le pas de la grille en X (un nombre de pixels)
double reso = sqrt(Vect.real()*Vect.real()+Vect.imag()*Vect.imag())/Image2Obj_Pas.real();
return reso;
}
bool OrientationGrille::GetPxMoyenne(double * aPxMoy) const
{
std::cout << "GetPxMoyenne" << std::endl;
std::cout << "Attention on n'a pas d'info sur l'altitude moyenne du sol dans les fichiers GRI"<< std::endl;
aPxMoy[0]=0.;
return true;
}
std::complex<double> OrientationGrille::interpolation(std::complex<double> position_grille,std::vector<double> const &grille,std::complex<int> Taille, int TZ) const
{
if ((Taille.real()<2)||(Taille.imag()<2)||(TZ<2))
return std::complex<double>(0.,0.);
int col = (int)floor(position_grille.real());
int lig = (int)floor(position_grille.imag());
if (col<0) col=0;
if (lig<0) lig=0;
if (col>(Taille.real()-2)) col = Taille.real()-2;
if (lig>(Taille.imag()-2)) lig = Taille.imag()-2;
double dcol = position_grille.real()-col;
double dlig = position_grille.imag()-lig;
// Les quatres Points autour de cette position
std::complex<double> A(grille[(lig*Taille.real()+col)*TZ],
grille[(lig*Taille.real()+col)*TZ+1]);
std::complex<double> B(grille[(lig*Taille.real()+col+1)*TZ],
grille[(lig*Taille.real()+col+1)*TZ+1]);
std::complex<double> C(grille[((lig+1)*Taille.real()+col)*TZ],
grille[((lig+1)*Taille.real()+col)*TZ+1]);
std::complex<double> D(grille[((lig+1)*Taille.real()+col+1)*TZ],
grille[((lig+1)*Taille.real()+col+1)*TZ+1]);
// Interpolation bi lineaire
std::complex<double> Pt((A.real()*(1-dcol)+B.real()*dcol)*(1-dlig)+(C.real()*(1-dcol)+D.real()*dcol)*dlig,
(A.imag()*(1-dcol)+B.imag()*dcol)*(1-dlig)+(C.imag()*(1-dcol)+D.imag()*dcol)*dlig);
return Pt;
}
/*Footer-MicMac-eLiSe-25/06/2007
Ce logiciel est un programme informatique servant à la mise en
correspondances d'images pour la reconstruction du relief.
Ce logiciel est régi par la licence CeCILL-B soumise au droit français et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL-B telle que diffusée par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilité au code source et des droits de copie,
de modification et de redistribution accordés par cette licence, il n'est
offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
seule une responsabilité restreinte pèse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concédants successifs.
A cet égard l'attention de l'utilisateur est attirée sur les risques
associés au chargement, à l'utilisation, à la modification et/ou au
développement et à la reproduction du logiciel par l'utilisateur étant
donné sa spécificité de logiciel libre, qui peut le rendre complexe à
manipuler et qui le réserve donc à des développeurs et des professionnels
avertis possédant des connaissances informatiques approfondies. Les
utilisateurs sont donc invités à charger et tester l'adéquation du
logiciel à leurs besoins dans des conditions permettant d'assurer la
sécurité de leurs systèmes et ou de leurs données et, plus généralement,
à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
pris connaissance de la licence CeCILL-B, et que vous en avez accepté les
termes.
Footer-MicMac-eLiSe-25/06/2007*/
| 39.367105 | 164 | 0.561015 | kikislater |
f7fe88faaa4bf4336174888bad7208757ee81f04 | 6,384 | cpp | C++ | hal/src/main/native/athena/PowerDistribution.cpp | team3990/allwpilib | 01ba56a8a6cb93cc42c8d980224b5205c1d01e4a | [
"BSD-3-Clause"
] | 39 | 2021-06-18T03:22:30.000Z | 2022-03-21T15:23:43.000Z | hal/src/main/native/athena/PowerDistribution.cpp | team3990/allwpilib | 01ba56a8a6cb93cc42c8d980224b5205c1d01e4a | [
"BSD-3-Clause"
] | 10 | 2021-06-18T03:22:19.000Z | 2022-03-18T22:14:15.000Z | hal/src/main/native/athena/PowerDistribution.cpp | team3990/allwpilib | 01ba56a8a6cb93cc42c8d980224b5205c1d01e4a | [
"BSD-3-Clause"
] | 4 | 2021-08-19T19:20:04.000Z | 2022-03-08T07:33:18.000Z | // Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "hal/PowerDistribution.h"
#include "CTREPDP.h"
#include "HALInternal.h"
#include "PortsInternal.h"
#include "REVPDH.h"
#include "hal/Errors.h"
#include "hal/handles/HandlesInternal.h"
using namespace hal;
extern "C" {
HAL_PowerDistributionHandle HAL_InitializePowerDistribution(
int32_t moduleNumber, HAL_PowerDistributionType type,
const char* allocationLocation, int32_t* status) {
if (type == HAL_PowerDistributionType::HAL_PowerDistributionType_kAutomatic) {
type = HAL_PowerDistributionType::HAL_PowerDistributionType_kCTRE;
}
if (type == HAL_PowerDistributionType::HAL_PowerDistributionType_kCTRE) {
if (moduleNumber == HAL_DEFAULT_POWER_DISTRIBUTION_MODULE) {
moduleNumber = 0;
}
return static_cast<HAL_PowerDistributionHandle>(
HAL_InitializePDP(moduleNumber, allocationLocation, status)); // TODO
} else {
if (moduleNumber == HAL_DEFAULT_POWER_DISTRIBUTION_MODULE) {
moduleNumber = 1;
}
return static_cast<HAL_PowerDistributionHandle>(
HAL_REV_InitializePDH(moduleNumber, allocationLocation, status));
}
}
#define IsCtre(handle) ::hal::isHandleType(handle, HAL_HandleEnum::CTREPDP)
void HAL_CleanPowerDistribution(HAL_PowerDistributionHandle handle) {
if (IsCtre(handle)) {
HAL_CleanPDP(handle);
} else {
HAL_REV_FreePDH(handle);
}
}
int32_t HAL_GetPowerDistributionModuleNumber(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPModuleNumber(handle, status);
} else {
return HAL_REV_GetPDHModuleNumber(handle, status);
}
}
HAL_Bool HAL_CheckPowerDistributionChannel(HAL_PowerDistributionHandle handle,
int32_t channel) {
if (IsCtre(handle)) {
return HAL_CheckPDPChannel(channel);
} else {
return HAL_REV_CheckPDHChannelNumber(channel);
}
}
HAL_Bool HAL_CheckPowerDistributionModule(int32_t module,
HAL_PowerDistributionType type) {
if (type == HAL_PowerDistributionType::HAL_PowerDistributionType_kCTRE) {
return HAL_CheckPDPModule(module);
} else {
return HAL_REV_CheckPDHModuleNumber(module);
}
}
HAL_PowerDistributionType HAL_GetPowerDistributionType(
HAL_PowerDistributionHandle handle, int32_t* status) {
return IsCtre(handle)
? HAL_PowerDistributionType::HAL_PowerDistributionType_kCTRE
: HAL_PowerDistributionType::HAL_PowerDistributionType_kRev;
}
int32_t HAL_GetPowerDistributionNumChannels(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return kNumCTREPDPChannels;
} else {
return kNumREVPDHChannels;
}
}
double HAL_GetPowerDistributionTemperature(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPTemperature(handle, status);
} else {
// Not supported
return 0;
}
}
double HAL_GetPowerDistributionVoltage(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPVoltage(handle, status);
} else {
return HAL_REV_GetPDHSupplyVoltage(handle, status);
}
}
double HAL_GetPowerDistributionChannelCurrent(
HAL_PowerDistributionHandle handle, int32_t channel, int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPChannelCurrent(handle, channel, status);
} else {
return HAL_REV_GetPDHChannelCurrent(handle, channel, status);
}
}
void HAL_GetPowerDistributionAllChannelCurrents(
HAL_PowerDistributionHandle handle, double* currents,
int32_t currentsLength, int32_t* status) {
if (IsCtre(handle)) {
if (currentsLength < kNumCTREPDPChannels) {
*status = PARAMETER_OUT_OF_RANGE;
SetLastError(status, "Output array not large enough");
return;
}
return HAL_GetPDPAllChannelCurrents(handle, currents, status);
} else {
if (currentsLength < kNumREVPDHChannels) {
*status = PARAMETER_OUT_OF_RANGE;
SetLastError(status, "Output array not large enough");
return;
}
return HAL_REV_GetPDHAllChannelCurrents(handle, currents, status);
}
}
double HAL_GetPowerDistributionTotalCurrent(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPTotalCurrent(handle, status);
} else {
return HAL_REV_GetPDHTotalCurrent(handle, status);
}
}
double HAL_GetPowerDistributionTotalPower(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPTotalPower(handle, status);
} else {
// Not currently supported
return 0;
}
}
double HAL_GetPowerDistributionTotalEnergy(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
return HAL_GetPDPTotalEnergy(handle, status);
} else {
// Not currently supported
return 0;
}
}
void HAL_ResetPowerDistributionTotalEnergy(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
HAL_ResetPDPTotalEnergy(handle, status);
} else {
// Not supported
}
}
void HAL_ClearPowerDistributionStickyFaults(HAL_PowerDistributionHandle handle,
int32_t* status) {
if (IsCtre(handle)) {
HAL_ClearPDPStickyFaults(handle, status);
} else {
HAL_REV_ClearPDHFaults(handle, status);
}
}
void HAL_SetPowerDistributionSwitchableChannel(
HAL_PowerDistributionHandle handle, HAL_Bool enabled, int32_t* status) {
if (IsCtre(handle)) {
// No-op on CTRE
return;
} else {
HAL_REV_SetPDHSwitchableChannel(handle, enabled, status);
}
}
HAL_Bool HAL_GetPowerDistributionSwitchableChannel(
HAL_PowerDistributionHandle handle, int32_t* status) {
if (IsCtre(handle)) {
// No-op on CTRE
return false;
} else {
return HAL_REV_GetPDHSwitchableChannelState(handle, status);
}
}
} // extern "C"
| 30.545455 | 80 | 0.695019 | team3990 |
7902f4e5ce76bdc4d61f5467c02544bbabca6ad9 | 640 | hpp | C++ | plugins/opengl/include/sge/opengl/target/set_flipped_area.hpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | 2 | 2016-01-27T13:18:14.000Z | 2018-05-11T01:11:32.000Z | plugins/opengl/include/sge/opengl/target/set_flipped_area.hpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | null | null | null | plugins/opengl/include/sge/opengl/target/set_flipped_area.hpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | 3 | 2018-05-11T01:11:34.000Z | 2021-04-24T19:47:45.000Z | // Copyright Carl Philipp Reh 2006 - 2019.
// 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)
#ifndef SGE_OPENGL_TARGET_SET_FLIPPED_AREA_HPP_INCLUDED
#define SGE_OPENGL_TARGET_SET_FLIPPED_AREA_HPP_INCLUDED
#include <sge/opengl/target/area_function.hpp>
#include <sge/renderer/pixel_rect.hpp>
#include <sge/renderer/screen_unit.hpp>
namespace sge::opengl::target
{
void set_flipped_area(
sge::opengl::target::area_function,
sge::renderer::pixel_rect const &,
sge::renderer::screen_unit);
}
#endif
| 26.666667 | 61 | 0.751563 | cpreh |
790447fed8c8faa47abe1aad69ef7308047b3001 | 1,461 | hpp | C++ | include/rlbwt_types.hpp | kampersanda/rcomp | 7cdbd286c18eca29ae5e0da50eeeecb5c289a602 | [
"MIT"
] | 3 | 2022-02-16T08:10:01.000Z | 2022-02-17T02:17:58.000Z | include/rlbwt_types.hpp | kampersanda/rcomp | 7cdbd286c18eca29ae5e0da50eeeecb5c289a602 | [
"MIT"
] | null | null | null | include/rlbwt_types.hpp | kampersanda/rcomp | 7cdbd286c18eca29ae5e0da50eeeecb5c289a602 | [
"MIT"
] | null | null | null | #pragma once
#include "FData_Naive.hpp"
#include "LData_Naive.hpp"
#include "LFIntervalGraph.hpp"
#include "Rlbwt_LFIG.hpp"
#include "GroupedFData_Naive.hpp"
#include "GroupedFData_Serialized.hpp"
#include "GroupedLData_Naive.hpp"
#include "GroupedLData_Serialized.hpp"
#include "GroupedLFIntervalGraph.hpp"
#include "Rlbwt_GLFIG.hpp"
namespace rcomp::rlbwt_types {
template <size_type t_DivBound = 7>
struct lfig_naive {
// Components
using ldata_type = LData_Naive<false>;
using fdata_type = FData_Naive<ldata_type>;
using graph_type = LFIntervalGraph<ldata_type, fdata_type, t_DivBound>;
// Compressor
using type = Rlbwt_LFIG<graph_type>;
};
template <size_type t_GroupedBound, size_type t_DivBound = 7>
struct glfig_naive {
// Components
using ldata_type = GroupedLData_Naive<t_GroupedBound, false>;
using fdata_type = GroupedFData_Naive<ldata_type>;
using graph_type = GroupedLFIntervalGraph<ldata_type, fdata_type, t_DivBound>;
// Compressor
using type = Rlbwt_GLFIG<graph_type>;
};
template <size_type t_GroupedBound, size_type t_DivBound = 7>
struct glfig_serialized {
// Components
using ldata_type = GroupedLData_Serialized<t_GroupedBound, false>;
using fdata_type = GroupedFData_Serialized<ldata_type>;
using graph_type = GroupedLFIntervalGraph<ldata_type, fdata_type, t_DivBound>;
// Compressor
using type = Rlbwt_GLFIG<graph_type>;
};
} // namespace rcomp::rlbwt_types | 31.085106 | 82 | 0.764545 | kampersanda |
7904ba5b69e6949c2728b7908c9d040da5b38e9d | 23,937 | cpp | C++ | Users.cpp | Yeeler/open-source-search-engine | 260864b36404a550c5268d2e2224c18d42e3eeb0 | [
"Apache-2.0"
] | null | null | null | Users.cpp | Yeeler/open-source-search-engine | 260864b36404a550c5268d2e2224c18d42e3eeb0 | [
"Apache-2.0"
] | null | null | null | Users.cpp | Yeeler/open-source-search-engine | 260864b36404a550c5268d2e2224c18d42e3eeb0 | [
"Apache-2.0"
] | null | null | null | #include "Users.h"
Users g_users;
RdbTree g_testResultsTree;
// intialize User members
User::User(){
m_permissions = 0;
m_numTagIds = 0;
m_numColls = 0;
m_allColls = false;
m_numIps = 0;
m_allIps = false;
m_numPages = 0;
m_allPages = 0;
m_reLogin = false;
m_username[0] = '\0';
m_password[0] = '\0';
}
// verify if user has permission from this ip
bool User::verifyIp ( int32_t ip ){
//
if ( m_allIps ) return true;
// check the iplist
for (uint16_t i=0; i < m_numIps; i++ ){
int32_t ipCheck = m_ip[i] & ( ip & m_ipMask[i] );
// check if they match
if ( ipCheck == m_ip[i] ) return true;
}
return false;
}
// verify user pass
bool User::verifyPassword ( char *pass ){
//
if ( ! pass ) return false;
if ( strcmp ( pass, m_password ) == 0 ) return true;
return false;
}
// verify is has access to this coll
bool User::verifyColl ( int32_t collNum ){
if ( m_allColls ) return true;
//
if ( collNum < 0 ) return false;
for ( uint16_t i=0; i < m_numColls; i++ )
if ( m_collNum[i] == collNum ) return true;
return false;
}
// verify if the user has the supplied tagId
bool User::verifyTagId ( int32_t tagId ){
//if ( tagId == 0 || tagId >= ST_LAST_TAG ) return false;
if ( tagId == 0 ) return false;
for ( uint16_t i = 0; i < m_numTagIds; i++ )
if ( m_tagId[i] == tagId ) return true;
return false;
}
// check if user is allowed to access this page
bool User::verifyPageNum ( uint16_t pageNum ){
if ( pageNum >= PAGE_NONE ) return false;
for ( uint16_t i = 0; i < m_numPages; i++ ){
bool allow = ! ( m_pages[i] & 0x8000 );
if ( pageNum == (m_pages[i] & 0x7fff) ) return allow;
}
// check if pageNum is of dummy page
bool isDummy = true;
//if ( pageNum > PAGE_PUBLIC )
isDummy = false;
//
if ( m_allPages && !isDummy )
return true;
return false;
}
// get first page
int32_t User::firstPage ( ){
// return first allowed page
for ( uint16_t i = 0; i < m_numPages; i++ )
if ( ! (m_pages[i] & 0x8000) ) //&&
// (m_pages[i]&0x7fff) > PAGE_PUBLIC )
return m_pages[i];
// if all pages is set then just return the root page
if ( m_allPages ) return PAGE_ROOT;
return -1;
}
// intialize the members
Users::Users(){
m_init = false;
m_needsSave = false;
}
Users::~Users(){
}
bool Users::save(){
if ( ! m_needsSave ) return true;
if ( ! m_loginTable.save(g_hostdb.m_dir,"userlogin.dat",NULL,0) )
return log("users: userlogin.dat save failed");
return true;
}
// initialize cache, tree, loadUsers and also loadTestUrls
bool Users::init(){
// 8 byte key is an ip/usernameHash and value is the timestamp
m_loginTable.set ( 8 , 4,0,NULL,0,false,0,"logintbl" );
// initialize the testresults rdbtree
//
int32_t nodeSize = (sizeof(key_t)+12+1) + sizeof(collnum_t);
int32_t maxNodes = MAX_TEST_RESULTS;
int32_t maxMem = maxNodes * nodeSize;
// only need to call this once
if ( ! g_testResultsTree.set ( 0 , // fixedDataSize
maxNodes ,
true , // do balancing?
maxMem ,
false , // own data?
"tree-testresults",
false , // dataInPtrs
NULL , // dbname
12 , // keySize
false ))
return false;
// call this userlogin.dat, not turkLoginTable.dat!!
//if ( ! m_loginTable.load(g_hostdb.m_dir,"userlogin.dat", NULL,NULL) )
// log("users: failed to load userlogin.dat");
// try to load the turk test results
loadTestResults();
// load users from the file
m_init = loadUserHashTable ();
m_needsSave = false;
return m_init;
}
// load turk test results from
bool Users::loadTestResults ( ){
//
File file;
char testFile[1024];
sprintf(testFile,"%sturkTestResults.dat", g_hostdb.m_dir );
file.set(testFile);
//
if ( ! file.doesExist() ) return false;
int32_t fileSize = file.getFileSize();
if (fileSize <= 0 ) return false;
// open the file
if ( !file.open(O_RDONLY) ){
log(LOG_DEBUG,"Users error operning test result file %s",
testFile );
return false;
}
char *buf = NULL;
int32_t bufSize = 4096;
int32_t offset = 0;
int32_t numNodes = 0;
// read the turk results file
for ( int32_t i=0; i < fileSize; ){
// bail out if no node left in tree
if ( numNodes >= MAX_TEST_RESULTS ) break;
buf = (char *)mmalloc(bufSize,"UserTestResults");
if ( !buf ){
log(LOG_DEBUG,"Users cannot allocate mem for test"
" file buf");
return false;
}
int32_t numBytesRead = file.read(buf,bufSize,offset);
if ( numBytesRead < 0 ){
log(LOG_DEBUG,"Users error reading test result file %s",
testFile );
mfree(buf,bufSize,"UsersTestResults");
}
// set the offsets
char *bufEnd = buf + numBytesRead;
char *newLineOffset = bufEnd;
for ( char *p = buf; p < bufEnd; p++ ){
char temp[250];
char *line = temp;
int32_t items = 0;
char username[10];
int32_t timestamp;
uint16_t result;
while ( *p != '\n' && p < bufEnd){
*line++ = *p++;
if ( *p != ' ' && *p != '\n' ) continue;
*line = '\0';
switch(items){
case 0: strcpy(username,temp);
break;
case 1: timestamp = atoi(temp);
break;
case 2: result = atoi(temp);
break;
}
line = temp;
items++;
}
if ( p < bufEnd && *p == '\n')
newLineOffset = p;
if ( p >= bufEnd && *p != '\n') break;
// if the fields are not 3 then the line is corrupt
if ( items == 3){
key_t key;
key.n1 = hash32n(username);
key.n0 = ((int32_t)timestamp << 8)
| (result & 0xff);
int32_t node =
g_testResultsTree.addNode(0,(char*)&key);
if ( node < 0 ){
log(LOG_DEBUG,"Users error adding node"
" to testResultsTree");
mfree(buf,bufSize,"UsersTestResults");
return false;
}
numNodes++;
}
//else
//log(LOG_DEBUG,"Users corrupt line turkTestResuls file"
// ": %s", temp);
}
// adjust the offset
offset = file.getCurrentPos() - (int32_t)(bufEnd - newLineOffset);
i += bufSize - (int32_t)( bufEnd - newLineOffset );
mfree(buf,bufSize,"UsersTestResults");
}
file.close();
return true;
}
int32_t Users::getAccuracy ( char *username, time_t timestamp ){
//
// get key between 15
key_t key;
key.n1 = hash32n(username);
key.n0 = ((int32_t)timestamp << 8);
int32_t refNode = g_testResultsTree.getPrevNode( 0 , (char *)&key);
if ( refNode == -1 )
refNode = g_testResultsTree.getNextNode ( 0 ,(char*)&key);
if ( refNode == -1 ) return -1;
// initialize the voting paramaters
int32_t totalVotes = 0;
int32_t totalCorrect = 0;
// get the vote from the reference node
key_t *refKey = (key_t*)g_testResultsTree.getKey(refNode);
if ( refKey->n1 == key.n1 ){
totalVotes++;
if ( refKey->n0 & 0x01 ) totalCorrect++;
}
// scan in the forward direction
int32_t currentNode = refNode;
//key_t currentKey = *refKey;
//currentKey.n0 += 2;
for ( int32_t i=0; i < ACCURACY_FWD_RANGE; i++ ){
int32_t nextNode = g_testResultsTree.getNextNode(currentNode);
if ( nextNode == -1) break;
key_t *nextKey = (key_t *)g_testResultsTree.getKey(nextNode);
if ( refKey->n1 == nextKey->n1 ){
totalVotes++;
if ( nextKey->n0 & 0x01 ) totalCorrect++;
}
currentNode = nextNode;
// currentKey = *nextKey;
// currentKey.n0 += 2;
}
// scan in the backward direction
currentNode = refNode;
//currentKey = *refKey;
//currentKey.n0 -= 2;
for ( int32_t i=0; i < ACCURACY_BWD_RANGE; i++ ){
int32_t prevNode = g_testResultsTree.getPrevNode(currentNode);
if ( prevNode == -1) break;
key_t *prevKey = (key_t *)g_testResultsTree.getKey(prevNode);
if ( refKey->n1 == prevKey->n1 ){
totalVotes++;
if ( prevKey->n0 & 0x01 ) totalCorrect++;
}
currentNode = prevNode;
//currentKey = *prevKey;
//currentKey.n0 -= 2;
}
// don't compute accuracy for few data points
if ( totalVotes < ACCURACY_MIN_TESTS ) return -1;
// compute accuracy in percentage
int32_t accuracy = ( totalCorrect * 100 ) / totalVotes;
return accuracy;
}
// . parses individual row of g_users
// . individual field are separated by :
// and , is used to mention many params in single field
bool Users::parseRow (char *row, int32_t rowLen, User *user ){
// parse individual user row
char *current = row;
char *end = &row[rowLen];
int32_t col = 0;
for ( ; col < 7 ;){
char temp[1024];
char *p = &temp[0];
bool hasStar = false;
while ( current <= end ){
if ( *current == ',' || *current == ':' ||
current == end ){
*p = '\0';
// star is present in data
// its allowed only for column 0 & 2
if (*current == '*' && col != 0 && col != 2 &&
col != 4 ){
log(LOG_DEBUG,"Users * can only"
"be user for collection,ip & pages: %s",
row );
return false;
}
// set the user param
setDatum ( temp, col, user, hasStar );
p = &temp[0];
// reset hasStar for all the other columns
// other then ip column 1
if ( col != 1 ) hasStar = false;
}
else {
//if ( *current == '*' || isalnum(*current) ||
// *current == '_' || *current=='.') {
if ( *current == '*' )
hasStar = true;
*p++ = *current;
}
current++;
if ( *(current-1) == ':') break;
//else{
// wrong format
// log(LOG_DEBUG,"Users error in log line: %s",
// row );
// return false;
//
}
if ( current >= end ) break;
col++;
QUICKPOLL(0);
}
if ( current < end ) return false;
return true;
}
// set individual user field from the given column/field
void Users::setDatum ( char *data, int32_t column, User *user, bool hasStar){
int32_t dataLen = gbstrlen (data);
if ( dataLen <= 0 || user == NULL || column < 0 ) return;
// set the user info depending on the column
// number or field
switch ( column ){
case 0:{
if ( user->m_allColls ) break;
if ( *data == '*' ){
user->m_allColls = true;
break;
}
collnum_t collNum = g_collectiondb.getCollnum(data);
if (collNum >= 0 ){
user->m_collNum[user->m_numColls] = collNum;
user->m_numColls++;
}
break;
}
case 2:{
if ( dataLen >= MAX_USER_SIZE ) data[MAX_USER_SIZE] = '\0';
strcpy ( user->m_username, data );
break;
}
case 1:{
if (user->m_allIps || user->m_numIps > MAX_IPS_PER_USER) break;
// scan ip
// if start is present find the location of *
uint32_t starMask = 0xffffffff;
if ( hasStar ){
char *p = data;
if ( *data == '*' && *(data+1) =='\0'){
user->m_allIps = true;
break;
}
// get the location of *
unsigned char starLoc = 4;
while ( *p !='\0'){
if ( *p == '*'){
// ignore the whole byte for
// that location
// set it to 0
*p = '0';
if ( starMask==0xffffffff )
starMask >>= 8*starLoc;
}
if ( *p == '.' ) starLoc--;
// starLoc = ceil(starLoc/2);
p++;
}
}
// if startMask means all ips are allowed
if ( starMask==0 ){ user->m_allIps = true; break;}
int32_t iplen = gbstrlen ( data );
int32_t ip = atoip(data,iplen);
if ( ! ip ) break;
user->m_ip[user->m_numIps] = ip;
user->m_ipMask[user->m_numIps] = starMask;
user->m_numIps++;
break;
}
case 3:{
if ( gbstrlen(data) > MAX_PASS_SIZE ) data[MAX_PASS_SIZE] = '\0';
strcpy ( user->m_password, data);
break;
}
case 5:{
if ( user->m_numPages >= MAX_PAGES_PER_USER ) break;
char *p = data;
user->m_pages[user->m_numPages]=0;
if ( hasStar ){
user->m_allPages = true;
break;
}
// if not allowed set MSB to 1
if ( *p == '-' ){
user->m_pages[user->m_numPages] = 0x8000;
p++;
}
int32_t pageNum = g_pages.getPageNumber(p);
if ( pageNum < 0 || pageNum >= PAGE_NONE ){
log(LOG_DEBUG,"Users Invalid Page - %s for user %s", p,
user->m_username );
break;
}
user->m_pages[user->m_numPages] |= ((uint16_t)pageNum & 0x7fff);
user->m_numPages++;
break;
}
case 6:{
// save the user permission
// only one user is allowed
// user permission keyword no longer used
/*if ( ! user->m_permissions & 0xff ){
if (strcmp(data,"master")==0)
user->m_permissions = USER_MASTER;
else if (strcmp(data,"admin")==0)
user->m_permissions = USER_ADMIN;
else if (strcmp(data,"client")==0)
user->m_permissions = USER_CLIENT;
else if (strcmp(data,"spam")==0)
user->m_permissions = USER_SPAM;
else if (strcmp(data,"public")==0)
user->m_permissions = USER_PUBLIC;
}else{ */
// save the tags
int32_t tagId = 0;
int32_t strLen = gbstrlen(data);
// backup over ^M
if ( strLen>1 && data[strLen-1]=='M' && data[strLen-2]=='^' )
strLen-=2;
//
// skip for now, it cores for "english" because we removed
// that tag from the list of tags in Tagdb.cpp
//
log("users: skipping language tag");
break;
tagId = getTagTypeFromStr ( data, strLen );
if ( tagId > 0 ) { // && tagId < ST_LAST_TAG ){
user->m_tagId[user->m_numTagIds] = tagId;
user->m_numTagIds++;
}
else {
log(LOG_DEBUG,"Users Invalid tagname - %s for user %s", data,
user->m_username );
//char *xx=NULL;*xx=0;
}
//}
break;
}
case 4:{
if ( *data == '1' && gbstrlen(data)==1 ) user->m_reLogin=true;
break;
}
default:
//
log(LOG_DEBUG, "Users invalid column data: %s", data);
}
}
// . load users from Conf::g_users if size of g_users
// changes and lastreadtime is > USER_DATA_READ_FREQ
// . returns false and sets g_errno on error
bool Users::loadUserHashTable ( ) {
// read user info from the file and add to cache
char *buf = &g_conf.m_users[0];
uint32_t bufSize = g_conf.m_usersLen;
//time_t now = getTimeGlobal();
// no users?
if ( bufSize <= 0 ) {
//log("users: no <users> tag in gb.conf?");
return true;
}
// what was this for?
//if ( bufSize <= 0 || ( bufSize == m_oldBufSize
// && (now - m_oldBufReadTime) < USER_DATA_READ_FREQ ))
// return false;
// init it
if ( ! m_ht.set (12,sizeof(User),0,NULL,0,false,0,"userstbl"))
return false;
// read user data from the line and add it to the cache
char *p = buf;
uint32_t i = 0;
for ( ; i < bufSize; i++){
// read a line from buf
char *row = p;
int32_t rowLen = 0;
while ( *p != '\r' && *p != '\n' && i < bufSize ){
i++; p++; rowLen++;
}
if ( *p == '\r' && *(p+1) == '\n' ) p+=2;
else if ( *p == '\r' || *p == '\n' ) p++;
if ( rowLen <= 0) break;
// set "user"
User user; if ( ! parseRow ( row, rowLen, &user) ) continue;
// skip empty usernames
if ( !gbstrlen(user.m_username) || !gbstrlen(user.m_password) )
continue;
// make the user key
key_t uk = hash32n ( user.m_username );
// grab the slot
int32_t slot = m_ht.getSlot ( &uk );
// get existing User record, "eu" from hash table
User *eu = NULL;
if ( slot >= 0 ) eu = (User *)m_ht.getValueFromSlot ( slot );
// add the user. will overwrite him if in there
if ( ! m_ht.addKey ( &uk , &user ) ) return false;
}
return true;
}
// . get User record from user cache
// . return NULL if no record found
User *Users::getUser (char *username ) { //,bool cacheLoad){
// bail out if init has failed
if ( ! m_init ) {
log("users: could not load users from cache ");
return NULL;
}
if ( ! username ) return NULL;
// check for user in cache
key_t uk = hash32n ( username );
return (User *)m_ht.getValue ( &uk );
}
// . check if user is logged
// . returns NULL if session is timedout or user not logged
// . returns the User record on success
User *Users::isUserLogged ( char *username, int32_t ip ){
// bail out if init has failed
if ( !m_init ) return (User *)NULL;
// get the user to the login cache
// get user record from cache
// return NULL if not found
User *user = getUser (username);
if ( !user ) return NULL;
//if ( user->m_reLogin ) return user;
// make the key a combo of ip and username
uint64_t key;
key = ((int64_t)ip << 32 ) | (int64_t)hash32n(username);
int32_t slotNum = m_loginTable.getSlot ( &key );
if ( slotNum < 0 ) return NULL;
// if this is true, user cannot time out
if ( user->m_reLogin ) return user;
// return NULL if user sesssion has timed out
int32_t now = getTime();
//int32_t timestamp = m_loginTable.getValueFromSlot(slotNum);
// let's make it a permanent login now!
//if ( (now-timestamp) > (int32_t)USER_SESSION_TIMEOUT ){
// m_loginTable.removeKey(key);
// return NULL;
//}
m_needsSave = true;
// if not timed out then add the new access time to the table
if ( ! m_loginTable.addKey(&key,&now) )
log("users: failed to update login of user %s : %s",username,
mstrerror(g_errno) );
return user;
}
// . login the user
// . adds the user to the login table
// . the valud is the last access timestamp of user
// which is used for session timeout
bool Users::loginUser ( char *username, int32_t ip ) {
// bail out if init has failed
if ( ! m_init ) return false;
// add the user to the login table
//key_t cacheKey = makeUserKey ( username, &cacheKey );
uint64_t key;
key = ((int64_t)ip << 32 ) | (int64_t)hash32n(username);
m_needsSave = true;
// add entry to table
int32_t now = getTime();
if ( m_loginTable.addKey(&key,&now) ) return true;
return log("users: failed to login user %s : %s",
username,mstrerror(g_errno));
}
bool Users::logoffUser( char *username, int32_t ip ){
uint64_t key;
key = ((int64_t)ip << 32 ) | (int64_t)hash32n(username);
m_loginTable.removeKey(&key);
return true;
}
char *Users::getUsername ( HttpRequest *r ){
// get from cgi before cookie so we can override
char *username = r->getString("username",NULL);
if ( !username ) username = r->getString("user",NULL);
// cookie is last resort
if ( !username ) username = r->getStringFromCookie("username",NULL);
//if ( !username ) username = r->getString("code",NULL);
// use the password as the user name if no username given
if ( ! username ) username = r->getString("pwd",NULL);
return username;
}
// check page permissions
bool Users::hasPermission ( HttpRequest *r, int32_t page , TcpSocket *s ) {
if ( r->isLocal() ) return true;
// get username from the request
char *username = getUsername(r);
// msg28 always has permission
if ( username &&
s &&
strcmp(username,"msg28")==0 ) {
Host *h = g_hostdb.getHostByIp(s->m_ip);
// we often ssh tunnel in through router0 which is also
// the proxy, but now the proxy uses msg 0xfd to forward
// http requests, so we no longer have to worry about this
// being a security hazard
//Host *p = g_hostdb.getProxyByIp(s->m_ip);
//if ( h && ! p ) return true;
// if host has same ip as proxy, DONT TRUST IT
//if ( h && p->m_ip == h->m_ip )
// return log("http: proxy ip same as host ip.");
if ( ! h )
return log("http: msg28 only good internally.");
// we are good to go
return true;
}
return hasPermission ( username, page );
}
// does user have permission to view and edit the parms on this page?
bool Users::hasPermission ( char *username, int32_t page ){
//if ( !username ) return false;
if ( ! username ) username = "public";
// get ths user from cache
User *user = getUser(username);
if ( !user ) return false;
// verify if user has access to the page
return user->verifyPageNum(page);
}
// get the highest user level for this client
//int32_t Pages::getUserType ( TcpSocket *s , HttpRequest *r ) {
bool Users::verifyUser ( TcpSocket *s, HttpRequest *r ){
//
//bool isIpInNetwork = true;//g_hostdb.isIpInNetwork ( s->m_ip );
if ( r->isLocal() ) return true;
int32_t n = g_pages.getDynamicPageNumber ( r );
User *user;
char *username = getUsername( r);
//if ( !username ) return false;
// if no username, assume public user. technically,
// they are verified as who they claim to be... noone.
if ( ! username ) return true;
// public user need not be verified
if ( strcmp(username,"public") == 0 ) return true;
// user "msg28" is valid as int32_t as he is on one of the machines
// and not the proxy ip
if ( s && strcmp(username,"msg28")==0 ) {
Host *h = g_hostdb.getHostByIp(s->m_ip);
if ( h && ! h->m_isProxy ) return true;
// if he's from 127.0.0.1 then let it slide
//if ( s->m_ip == 16777343 ) return true;
//if ( h && h->m_isProxy ) return true;
// otherwise someone could do a get request with msg28
// as the username and totally control us...
return log("http: msg28 only good internally and not "
"from proxy.");
}
char *password = r->getString("pwd",NULL);
// this is the same thing!
if ( password && ! password[0] ) password = NULL;
/*
// the possible proxy ip
int32_t ip = s->m_ip;
// . if the request is from the proxy, grab the "uip",
// the "user ip" who originated the query
// . now the porxy uses msg 0xfd to forward its requests so if we
// receive this request from ip "ip" it is probably because we are
// doing an ssh tunnel through router0, which is also the proxy
if ( g_hostdb.getProxyByIp ( ip ) ) {
// attacker could add uip=X and gain access if we are logged
// in through X. now we have moved the proxy off of router0
// and onto gf49...
return log("gb: got admin request from proxy for "
"user=%s. ignoring.",username);
}
*/
// if the page is login then
// get the username from the request
// and login the user if valid
if ( n == PAGE_LOGIN ){
//
//username = r->getString("username");
//char *password = r->getString("pwd");
// if no username return
//if ( ! username ) return 0;
// get the user information
user = g_users.getUser ( username );
// if no user by that name
// means bad username, return
if ( ! user ) return 0;
// verify pass and return if bad
if ( ! user->verifyPassword ( password ) ) return 0;
}
else if ( password ) {
user = g_users.getUser(username);
if (!user) return 0;
//password = r->getString("pwd",NULL);
if ( !user->verifyPassword( password) ) return 0;
// . add the user to the login cache
// . if we don't log him in then passing the username/pwd
// in the hostid links is not good enough, we'd also have
// to add username/pwd to all the other links too!
g_users.loginUser(username,s->m_ip);
}
else {
// check the login table and users cache
user = g_users.isUserLogged ( username, s->m_ip );
// . if no user prsent return 0 to indicate that
// user is not logged in.
// . MDW: no, because the cookie keeps sending
// username=mwells even though i don't want to login...
// i just want to do a search and be treated like public
if ( ! user ) return 0;
}
// verify ip of the user
bool verifyIp = user->verifyIp ( s->m_ip );
if ( ! verifyIp ) return 0;
// verify collection
char *coll = r->getString ("c");
if( !coll) coll = g_conf.m_defaultColl;
int32_t collNum = g_collectiondb.getCollnum(coll);
bool verifyColl = user->verifyColl (collNum);
if ( ! verifyColl ) return 0;
// add the user to the login cache
if ( n == PAGE_LOGIN || n == PAGE_LOGIN2 ){
if ( ! g_users.loginUser ( username, s->m_ip ) ) return 0;
}
// now if everything is valid
// get the user permission
// i.e USER_MASTER | USER_ADMIN etc.
//int32_t userType = user->getPermissions ( );
// . Commented by Gourav
// . Users class used
//hif ( userType == USER_MASTER || userType == USER_ADMIN
// || userType == USER_PUBLIC )
// userType &= isIpInNetwork;
//if ( g_conf.isMasterAdmin ( s , r ) ) return USER_MASTER;
// see if has permission for specified collection
//CollectionRec *cr = g_collectiondb.getRec ( r );
// if no collection specified, assume public access
//if ( ! cr ) return USER_PUBLIC;
//if ( cr->hasPermission ( r , s ) ) return USER_ADMIN;
//if ( cr->isAssassin ( s->m_ip ) ) return USER_SPAM;
// otherwise, just a public user
//return USER_PUBLIC;
//return userType;
return true;
}
| 26.685619 | 77 | 0.618081 | Yeeler |
790668ab16a374fc5914f305f2afa4855615ed99 | 37,027 | cpp | C++ | FindMeSAT_SW/amateurfunk-funkrufmaster_19862/src/digi.cpp | DF4IAH/GPS-TrackMe | 600511a41c995e98ec6e06a9e5bb1b64cce9b7a6 | [
"MIT"
] | 2 | 2018-01-18T16:03:41.000Z | 2018-04-01T15:55:59.000Z | FindMeSAT_SW/amateurfunk-funkrufmaster_19862/src/digi.cpp | DF4IAH/GPS-TrackMe | 600511a41c995e98ec6e06a9e5bb1b64cce9b7a6 | [
"MIT"
] | null | null | null | FindMeSAT_SW/amateurfunk-funkrufmaster_19862/src/digi.cpp | DF4IAH/GPS-TrackMe | 600511a41c995e98ec6e06a9e5bb1b64cce9b7a6 | [
"MIT"
] | 2 | 2020-05-22T17:01:24.000Z | 2021-10-08T15:53:01.000Z | /****************************************************************************
* *
* *
* Copyright (C) 2002-2004 by Holger Flemming *
* *
* This Program is free software; you can redistribute ist and/or modify *
* it under the terms of the GNU General Public License as published by the *
* Free Software Foundation; either version 2 of the License, or *
* (at your option) any later versions. *
* *
* This program is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRENTY; 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 receved a copy of the GNU General Public License along *
* with this program; if not, write to the Free Software Foundation, Inc., *
* 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
****************************************************************************
* *
* Author: *
* Jens Schoon, DH6BB email : dh6bb@darc.de *
* PR : dh6bb@db0whv.#nds.deu.eu *
* *
* List of other authors: *
* Holger Flemming, DH4DAI email : dh4dai@amsat.org *
* PR : dh4dai@db0wts.#nrw.deu.eu *
* *
****************************************************************************/
#include "digi.h"
#include "spoolfiles.h"
#include "board.h"
#include "logfile.h"
#include "callsign.h"
String digi_config_file::digi_typen[5]={"UNKNOWN", "FLEX", "TNN", "XNET" };
/* Hier mal einige Gedanken dazu von DH6BB:
Linkstatus:
12345678901234567890
DB0WHV<>DB0LER 11/12
DB0WHV<>DB0BHV 1+/3+ (Laufzeit 100/300 bis 199/399)
DB0WHV<>DB0PDF 2+/1* (Laufzeit 200/1000 bis 299/1999)
DB0WHV<>DB0TNC --/-- (Kein Link)
DB0WHV<>DB0SM (-/-) (Link weg, gibt aber Umweg)
DB0WHV<>DB0SM (./.) (Laufzeit 10/10 bis 99/99, gibt aber schnelleren Umweg)
Wir nehmen die Zahlen von Flexnet. TNN-Zeiten teilen wir durch 100.
Das entspricht etwa den Flexnet-Zeiten.
Digi-Status:
12345678901234567890
DB0WHV Up: 123d
Destinations : 689
Zeile noch frei
Zeile noch frei
Bitte Kommentare.
Hier der Vorschlag von DH4DAI:
Die gesamte Rubrik "Digipeater" besteht aus 10 Slots a 4 Zeilen, also aus
40 Zeilen. Jeder Digipeater, der automatisch abgefragt wird, erhaelt eine
Statuszeile. Darunter koennen fuer jeden Digipeater beliebig viele Einstiege
und Links konfiguriert werden, deren Status ebenfalls in einer Zeile
dargestellt wird.
Es gibt die folgenden Formate:
Statuszeile eines Digipeaters:
==============================
12345678901234567890
DB0WTS/JO31NK ##:##*
------ Uptime
Das Format der Zeitausgabe der Klasse delta_t muss fuer die Uptime leicht
modifiziert werden, da normalerweise ein Leerzeichen vor der Dimension
eingefuegt wird. Dies ist hier aus Platzgruenden nicht moeglich.
Bei den Statuszeilen von Einstiegen und Links wurden als Grundlage die bei
RMNC/Flexnet zur Verfuegung stehenden Informationen benutzt. Fuer andere
Knotenrechnersysteme muss geschaut werden, ob diese Informationen zur
Verfuegung stehen oder ob andere Informationen angezeigt werden koennen
Statuszeile eines Einstiegs
===========================
12345678901234567890
70cm ### #.## * ###
--- Quality
------ Datenrate
--- Anzahl der QSOs
---- Kuerzel des Einstiegs
Die Quality wird von Flexnet der Prozentsatz der als korrekt bestaetigten
Info-Frames auf der Anzeige angezeigt. Es handelt sich um einen Integer
zwischen 0 und 100
Die Datenrate wird bei Flexnet in KByte / 10min angegeben. Um einen direkten
Vergleich zur Nenndatenrate zu haben, kann diese Datenrate in Bit/s
(1 KByte / 10min = 13,653 Bit/s ) umgerechnet werden. Es werden beide
Richtungen addiert.
Die Anzahl der QSOs auf diesem Port wird von Flexnet direkt ausgegeben
Als Kuerzel dient eine eindeutige Kennung dieses Einstiegs aus vier Zeichen,
z.B. '70cm' ' 2m ', ' 9k6' oder '76k8'
Statuszeile eines Links
=======================
12345678901234567890
0IUZ #.## * ## #####
----- Linkzeit
-- Quality
------ Datenrate
---- Kuerzel
Die Linkzeit wird in einer Notation angegeben, wie von Jens vorgeschlagen
Fuer die Quality stehen hier nur zwei Ziffern zur Verfuegung eine Quality von
100% wird mit '1+' angegeben.
Fuer die Datenrate gilt das gleiche, wie bei den Einstiegen
Das Kuerzel ist hier wiede eine eindeutige Kennung aus vier Buchstaben,
ueblicherweise Ziffer und Suffix des Rufzeichens des Linkpartners
Zusatzfunktion Sysopalarm
=========================
Fuer den Fall, dass sich bestimmte Parameter derart verschlechtern, dass
die Vermutung besteht, dass ein technisches Problem aufgetreten ist, kann
als Zusatzfunktion ein Funkruf zu einem technischen Verantwortlichen
ausgeloest werden. Folgende Alarmzustaende sind moeglich:
* Digipeateralarm
Wird ausgeloest, wenn ein Digipeaterneustart erkannt wurde oder wenn ein
Verbindungsaufbau zu diesem Digipeater gescheitert ist.
Ein Digipeaterneustart ist daran zu erkennen, dass die Uptime kleiner ist,
als bei der letzten Abfrage.
* Einstiegsalarm
Wird ausgeloest, wenn die Uebertragungsqualitaet auf diesem Einstieg
signifikant abgesunken ist.
* Linkalarm
Wird ausgeloest, wenn die Uebertragungsqualitaet auf diesem Link
signifikant abgesunken ist oder die Linkzeiten signifikant angestiegen sind.
Was als signifikante abnahme oder anstieg gewertet wird, muss noch genau
definiert werden.
Die Konfiguration erfolgt ueber eine Konfigurationsdatei, deren Format wie
folgt aussehen koennte:
#
# Kommentare,
#
#
# Hier beginnt jetzt die Konfiguration eines Digipeaters
#
DIGI <rufzeichen>
#
# Zur Digikonfiguration gehoeren Pfad, Digityp, etc
#
PFAD <connect_pfad>
#
TYP [FLEX|TNN|...]
#
ALARM <rufzeichen>,<rufzeichen>,...
#
# gibt an, wer bei einem Digipeateralarm zu alarmieren ist
#
# Nun beginnt die Konfiguration eines Einstiegs
#
EINSTIEG <kuerzel> <port-nr>
#
ALARM <rufzeichen>,<rufzeichen>,...
#
ENDE
#
# Ende der Einstiegsdeklaration
#
# Nun beginnt die Linkdeklaration
#
LINK <kuerzel> <port-nr>
#
ALARM <rufzeichen>,<rufzeichen>,...
#
ENDE
#
# Ende der Linkdeklaration
#
#
ENDE
#
# Ende der Digipeaterdeklaration
#
#
Fehlt noch was in der Konfiguration ?
Kommentare zu meinem Vorschlag ???
*/
extern config_file configuration;
extern spoolfiles spool;
extern callsign G_mycall;
extern digi_control Digi;
digi_control::digi_control(void)
{
start_flag = false;
start_first = false;
activ = false;
last_fetch = zeit(-1);
}
digi_control::~digi_control(void)
{
}
/*
----------------------------------------------------------------------------
zunaechst kommen alle Methoden der Konfigurations-Datei-Klasse
digi_config_files
----------------------------------------------------------------------------
*/
digi_config_file::digi_config_file( void )
{
slot = 0;
};
digi_config_file::digi_config_file( String & dname )
{
read(dname);
}
void digi_config_file::read( String & dname )
{
ifstream cfg_file(strtochar(dname));
if (!cfg_file)
throw Error_could_not_open_digi_configfile();
else
{
dateiname = dname;
String line;
link_anzahl=0;
enabled=false;
while (cfg_file)
{
line.getline(cfg_file,250);
int l = line.slen();
if (l > 0 && line[0] != '#')
{
try
{
int p;
digi.set_format(false);
if ((p = line.pos(String('='))) != -1 )
{
String parameter = line.copy(0,p);
String wert = line.copy(p+1,l-p-1);
wert.kuerze();
if (parameter == "DIGI")
digi = callsign(wert);
else if (parameter == "SLOT")
slot = wert.Stoi();
else if (parameter == "STATUS" )
{
if (wert=="ENABLED")
enabled=true;
}
else if (parameter == "TYP" )
{
if (wert=="TNN")
typ=tnn;
else if (wert=="FLEX")
typ=flexnet;
else if (wert=="XNET")
typ=xnet;
else
typ=unknown;
}
else if (parameter == "PFAD")
pfad = connect_string(wert);
else if (parameter == "LINK")
{
link_call[link_anzahl] = callsign(wert);
link_anzahl++;
}
else
throw Error_unknown_parameter_in_digi_configfile();
}
else
throw Error_wrong_format_in_digi_config_file();
}
catch( Error_syntax_fehler_in_connect_string )
{
throw Error_wrong_format_in_digi_config_file();
}
catch( Error_no_callsign )
{
throw Error_wrong_format_in_digi_config_file();
}
catch( Error_not_a_locator )
{
throw Error_wrong_format_in_digi_config_file();
}
}
}
}
#ifdef _DEBUG_DIGI_
cerr << "DIGI: " << digi << " Typ: " << digi_typen[typ] << " Path: " << pfad << endl;
cerr << "Links: " << link_anzahl << endl;
#endif
}
void digi_config_file::PrintOn( ostream &strm )
{
callsign call;
digi.set_format(false);
strm << "#" << endl;
strm << "# Digi-configuration-file!" << endl;
strm << "# automaticaly generated, please do not edit!" << endl;
strm << "#" << endl;
if (enabled)
strm << "STATUS=ENABLED" << endl;
else
strm << "STATUS=DISABLED" << endl;
strm << "DIGI=" << digi << endl;
strm << "PFAD=" << pfad << endl;
strm << "TYP=" << digi_typen[typ] << endl;
strm << "SLOT=" << slot << endl;
for (int i=0; i<link_anzahl; i++)
{
try
{
call=callsign(link_call[i]);
strm << "LINK=" << link_call[i] << endl;
}
catch (Error_no_callsign)
{
}
}
strm << "#" << endl;
}
void digi_config_file::show(ostream &strm, char cr )
{
digi.set_format(true);
digi.set_nossid(false);
strm << digi << setw(2) << slot << setw (8) << digi_typen[typ] << " " << link_anzahl << " " << pfad << cr;
digi.set_format(false);
}
void digi_config_file::full_show(ostream &strm, char cr )
{
digi.set_format(true);
digi.set_nossid(false);
strm << "Digi : " << digi << cr;
strm << "Digi-Typ : " << digi_typen[typ] << cr;
strm << "Slot : " << slot << cr;
strm << "Connect-Pfad : " << pfad << cr;
for (int i=0; i<link_anzahl; i++)
strm << "Link : " << link_call[i] << cr;
digi.set_format(false);
if (enabled)
strm << "Status : Enabled" << cr;
else
strm << "Status : Disabled" << cr;
}
void digi_config_file::save(void)
{
ofstream ostr(strtochar(dateiname));
#ifdef _DEBUG_DIGI_
cerr << "SAVE Digistat" << endl;
#endif
if (ostr)
{
PrintOn(ostr);
}
}
digi_config_file::~digi_config_file( void )
{
}
void digi_control::start(void)
{
if (activ)
{
start_flag = true;
start_first = true;
}
}
bool digi_control::set_status(const callsign &call, bool status)
{
try
{
digi_config_file digicfg = digifiles.find(call);
digicfg.enabled=status;
if (digifiles.set(call,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
bool digi_control::set_typ(const callsign &call, const String &typ)
{
try
{
digi_config_file digicfg = digifiles.find(call);
digicfg.typ=unknown;
if (typ=="TNN")
digicfg.typ=tnn;
else if (typ=="FLEX")
digicfg.typ=flexnet;
else if (typ=="XNET")
digicfg.typ=xnet;
if (digifiles.set(call,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
// Der Destruktor bleibt leer
digi_status::~digi_status( void )
{
}
digi_interface::digi_interface(String &outp, bool ax_flag, digi_config_file &digi_confg) : interfaces(outp,ax_flag)
{
digi_cfg = digi_confg; // Daten in klasseninterner Variablen speichern
set_maske();
mdg.gefundene_links=0;
set_connect_path(digi_cfg.pfad);
first_connect(outp);
interface_id = 'I';
last_activity = zeit();
mdg.call = digi_cfg.digi;
}
// Der Destruktor bleibt leer
digi_interface::~digi_interface( void )
{
}
bool digi_interface::do_process( bool rx_flag, String &outp )
{
digi_control Digi;
outp = "";
if (rx_flag)
{
String inp;
while (get_line(inp))
{
// Steht in der Zeile "reconnected" ? Dann wird der Prozess beendet
if (inp.in("*** reconnected") || inp.in("Reconnected to"))
return false;
else
{
if (connect_prompt)
{
if (maske != 0)
digi_line(inp);
if (maske == 0)
{
Digi.meldung(digi_cfg.slot,mdg,digi_cfg);
in_msg++;
#ifdef _DEBUG_DIGI_
cerr << "Maske ist Null" << endl;
#endif
return false;
}
}
else
{
#ifdef _DEBUG_DIGI_
cerr << "Connected" << endl;
#endif
String command;
switch (digi_cfg.typ)
{
case flexnet:
command = "p *";
break;
case xnet:
command = "s *\r\nl";
break;
case tnn:
command = "s\r\nr v";
break;
default:
return false;
}
outp.append(command + char(13)); // Befehl senden
connect_prompt=true;
last_activity = zeit();
}
}
}
}
return true;
}
digi_config_files::digi_config_files( void )
{
files.clear();
}
digi_config_files::digi_config_files( config_file& cfg )
{
files.clear();
syslog slog(cfg);
try
{
digi_dir_name = cfg.find("DIGI");
DIR *digi_dir;
digi_dir = opendir(strtochar(digi_dir_name));
if (digi_dir != NULL)
{
struct dirent *entry;
while ((entry = readdir(digi_dir)) != NULL )
{
if ( (strcmp(entry->d_name,".") != 0) && (strcmp(entry->d_name,"..")))
{
String fname(digi_dir_name + entry->d_name);
if (fname.in(String(".digi")))
try
{
files.push_back(digi_config_file(fname));
}
catch(Error_could_not_open_digi_configfile)
{
slog.eintrag("Digi-Configurationsfile "+fname+" nicht zu oeffnen",LOGMASK_PRGRMERR);
}
catch(Error_unknown_parameter_in_digi_configfile)
{
slog.eintrag("Unbekannter Parameter in digi-Config-Datei "+fname,LOGMASK_PRGRMERR);
}
catch(Error_wrong_format_in_digi_config_file)
{
slog.eintrag("Falsches Dateiformat in digi-Config-Datei "+fname,LOGMASK_PRGRMERR);
}
}
}
closedir(digi_dir);
}
}
catch( Error_parameter_not_defined )
{
}
}
bool digi_config_files::get_first( digi_config_file &f )
{
it = files.begin();
if (it != files.end())
{
f = *it;
return true;
}
else
return false;
}
bool digi_config_files::get_next( digi_config_file &f )
{
if (it == files.end())
return false;
else
{
it++;
if (it != files.end())
{
f = *it;
return true;
}
else
return false;
}
}
bool digi_control::add_link( const callsign &digicall, const callsign &linkcall )
{
try
{
digi_config_file digicfg = digifiles.find(digicall);
for (int a=0; a<digicfg.link_anzahl; a++)
{
if(samecall(digicfg.link_call[a],linkcall))
return false;
}
digicfg.link_call[digicfg.link_anzahl] = linkcall;
digicfg.link_anzahl++;
if (digifiles.set(digicall,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
bool digi_control::del_link( const callsign &digicall, const callsign &linkcall )
{
try
{
int a=0, b=0;
digi_config_file digicfg = digifiles.find(digicall);
for (a=0; a<digicfg.link_anzahl; a++)
{
if(samecall(digicfg.link_call[a],linkcall))
{
}
else
{
digicfg.link_call[b] = digicfg.link_call[a];
b++;
}
}
if (a==b)
return false;
digicfg.link_anzahl=b;
if (digifiles.set(digicall,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
bool digi_control::add( const callsign &call )
{
digi_config_file digicfg;
digicfg.digi = call;
return digifiles.add(digicfg);
}
bool digi_control::del( const callsign &call )
{
digi_config_file digicfg;
digicfg.digi = call;
return digifiles.del(call);
}
bool digi_config_files::add( digi_config_file digicfg )
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
if (samecall(digicfg.digi,i->digi))
return false;
}
String dname = digi_dir_name + digicfg.digi.str() + ".digi";
#ifdef _DEBUG_DIGI_
cerr << "Digi: " << dname << endl;
#endif
digicfg.dateiname = dname;
digicfg.slot=1;
digicfg.typ=unknown;
digicfg.pfad=connect_string("no:n0cal>n0cal");
digicfg.link_anzahl=0;
digicfg.enabled=false;
files.push_back(digicfg);
digicfg.save();
return true;
}
bool digi_config_files::del( const callsign &call )
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
if (samecall(call,i->digi))
{
remove(strtochar(i->dateiname));
files.erase(i);
it = files.begin();
return true;
}
}
return false;
}
bool digi_config_files::set( const callsign &call, const digi_config_file &digicfg )
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
if (samecall(call,i->digi))
{
*i = digicfg;
return true;
}
}
return false;
}
digi_config_file& digi_config_files::find( const callsign &call )
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
if (samecall(call,i->digi))
return *i;
}
throw Error_unknown_digi();
}
void digi_config_files::show( ostream &ostr , char cr )
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
i->show(ostr, cr);
}
}
void digi_config_files::full_show(const callsign &call, ostream &ostr, char cr)
{
for (vector<digi_config_file>::iterator i = files.begin() ; i != files.end() ; ++i)
{
if (samecall(call,i->digi))
{
#ifdef _DEBUG_DIGI_
cerr << "Samecall: " << call << endl;
#endif
i->full_show(ostr,cr);
}
}
}
void digi_control::load( config_file & cfg )
{
digifiles = digi_config_files(cfg);
ds = get_default_destin();
try
{
String en = cfg.find("DIGI_STATUS");
en.kuerze();
if ( en == "JA" )
activ = true;
else
activ = false;
}
catch ( Error_parameter_not_defined )
{
activ = false;
}
}
void digi_control::show( ostream &ostr, char cr )
{
digifiles.show(ostr,cr);
ostr << cr << cr;
ostr << "Status : ";
if (activ)
ostr << " activ";
else
ostr << "inactiv";
ostr << cr << cr;
}
void digi_control::full_show(const callsign &call, ostream &ostr, char cr)
{
digifiles.full_show(call, ostr, cr);
}
bool digi_control::start_connection( digi_config_file &digicfg )
{
if (start_flag)
{
if (start_first)
{
if ( !digifiles.get_first(digicfg) )
{
start_flag = false;
start_first = false;
return false;
}
else
{
start_first = false;
if (digicfg.enabled==false)
return false;
last_fetch = zeit();
return true;
}
}
else
if ( !digifiles.get_next(digicfg) )
{
start_flag = false;
return false;
}
else
{
if (digicfg.enabled==false)
return false;
last_fetch = zeit();
return true;
}
}
else
return false;
}
/*
----------------------------------------------------------------------------
Nun folgen die Methoden der Klasse digi_meldung
----------------------------------------------------------------------------
*/
digi_meldung::digi_meldung( void )
{
uptime = 0;
destin = -1;
}
String digi_meldung::spool_msg_digi( void ) const
{
// Erste Zeile enthaelt Rufzeichen
int pos=1;
zeit jetzt;
callsign c = call;
delta_t Uptime = uptime;
c.set_format(true);
// c.set_nossid(true);
String tmp = c.call();
jetzt.set_darstellung(zeit::f_zeit_s);
pos=tmp.slen()+5;
while(pos++<20) tmp.append(" ");
tmp.append(jetzt.get_zeit_string());
tmp.append("Uptime: ");
tmp.append((Uptime.get_string()));
pos=tmp.slen();
while(pos++<40) tmp.append(" ");
tmp.append("Destin: ");
tmp.append(itoS(destin,4));
return tmp;
}
String digi_meldung::spool_msg_link(digi_config_file &digi_cfg) const
{
String von = call.str();
String an;
if (von.slen()<6) von.append(" ");
String tmp;
for(int i=0; i<digi_cfg.link_anzahl; i++)
{
an=digi_cfg.link_call[i].str();
if (an.slen()<6) an.append(" ");
tmp.append(von+"<>"+an+" "+link_rtt[i]);
}
if (tmp.slen()<2) tmp="---";
return tmp;
}
void digi_control::meldung( int slot, const digi_meldung &mldg, digi_config_file &digi_cfg )
{
String msg;
msg = mldg.spool_msg_digi();
spool_msg(slot,msg,RUB_DIGI_STAT);
// ToDo: Slots + >4 Links
// if (mdg.link_anzahl>0)
{
msg = mldg.spool_msg_link(digi_cfg);
spool_msg(slot,msg,RUB_LINK_STAT);
}
}
void digi_control::spool_msg( int sl, const String &msg, String rubrik )
{
int slot;
syslog logf(configuration);
try
{
board brd(rubrik,configuration);
int board = brd.get_brd_id();
if (sl > 10) //Rotierende Slots
slot = brd.get_slot();
else
slot = sl; //fester Slot
brd.set_msg(msg,slot,ds);
// Nachricht ins Spoolverzeichnis schreiben
spool.spool_bul(G_mycall,zeit(),board,slot,msg,false,ds,128);
}
// Moegliche Fehler-Exceptions abfangen
catch( Error_could_not_open_file )
{
logf.eintrag("Nicht moeglich, Datei im Spoolverzeichnis zu oeffnen",LOGMASK_PRGRMERR);
}
catch( Error_could_not_open_boardfile )
{
logf.eintrag("Digi Boarddatei nicht angelegt.",LOGMASK_PRGRMERR);
}
catch( Error_could_not_create_boardfile )
{
logf.eintrag("Nicht moeglich, Digi Boarddatei zu speichern.",LOGMASK_PRGRMERR);
}
}
void digi_interface::set_maske( void )
{
maske=0;
if ( digi_cfg.typ == flexnet )
{
#ifdef _DEBUG_DIGI_
cerr << "Typ ist Flexnet" << endl;
#endif
maske |= MASKE_UPTIME;
maske |= MASKE_DESTINATION;
maske |= MASKE_LINK;
}
if ( digi_cfg.typ == tnn )
{
#ifdef _DEBUG_DIGI_
cerr << "Typ ist TNN" << endl;
#endif
maske |= MASKE_UPTIME;
maske |= MASKE_DESTINATION;
maske |= MASKE_LINK;
}
if ( digi_cfg.typ == xnet )
{
#ifdef _DEBUG_DIGI_
cerr << "Typ ist XNET" << endl;
#endif
maske |= MASKE_UPTIME;
maske |= MASKE_DESTINATION;
maske |= MASKE_NODES;
maske |= MASKE_LINK;
}
#ifdef _DEBUG_DIGI_
cerr << "Maske: " << maske << endl;
#endif
}
void digi_interface::digi_line( String line )
{
switch (digi_cfg.typ)
{
case flexnet:
flex_digi_line(line);
break;
case tnn:
tnn_digi_line(line);
break;
case xnet:
xnet_digi_line(line);
break;
default:
break;
}
}
void digi_interface::flex_digi_line( String line )
{
last_activity = zeit();
double up = 0;
if ( maske & MASKE_DESTINATION )
{
if (line.in(String("d:")) &&
line.in(String("v:")) &&
line.in(String("t:")))
{
int pos1=0, pos2=0;
String dests;
if((pos1=line.pos("d:")) && (pos2=line.pos("v:")))
{
dests=line.part(pos1+2,pos2-pos1-2);
#ifdef _DEBUG_DIGI_
cerr << ">>" << dests << "<<" << endl;
#endif
mdg.destin = dests.Stoi();
maske &= ~MASKE_DESTINATION;
}
}
}
if ( maske & MASKE_UPTIME )
{
if (line.in(String("d:")) &&
line.in(String("v:")) &&
line.in(String("t:")))
{
int pos1=0, pos2=0, pos3=0;
String Uptime;
if((pos1=line.pos("t:")) && (pos2=line.pos(")")))
{
Uptime=line.part(pos1+2,pos2-pos1-2);
if ((pos3=Uptime.pos(","))) // 7h, 23m
{
String high, low;
high=Uptime.part(0,pos3);
low=Uptime.part(pos3+1,Uptime.slen()-pos3-1);
#ifdef _DEBUG_DIGI_
cerr << ">>" << Uptime << "<<>>" << high << "<<>>" << low << "<<" << endl;
#endif
if (high.in("d"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*24*60*60;
}
if (high.in("h"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*60*60;
}
if (high.in("m"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*60;
}
if (high.in("s"))
{
high.part(0,high.slen()-2); up=high.Stoi();
}
if (low.in("h"))
{
low.part(0,low.slen()-2); up+=low.Stoi()*60*60;
}
if (low.in("m"))
{
low.part(0,low.slen()-2); up+=low.Stoi()*60;
}
if (low.in("s"))
{
low.part(0,low.slen()-2); up+=low.Stoi();
}
}
else
{
if (Uptime.in("s"))
{
Uptime.part(0,Uptime.slen()-2); up+=Uptime.Stoi();
}
}
#ifdef _DEBUG_DIGI_
cerr << "Uptime: " << delta_t(up) << endl;
#endif
mdg.uptime=delta_t(up);
maske &= ~MASKE_UPTIME;
}
}
}
if ( maske & MASKE_LINK )
{
String Linkcall;
String hin, rueck;
String laufzeit;
String ssid;
if (line.slen()>70)
{
Linkcall=line.part(54,7);
try
{
for(int anzahl=0; anzahl<digi_cfg.link_anzahl; anzahl++)
{
//cerr << "Call:" << digi_cfg.link_anzahl << digi_cfg.link_call[anzahl] << endl;
if (samecall(callsign(Linkcall),digi_cfg.link_call[anzahl]))
{
laufzeit=line.part(66,line.slen()-66);
ssid=line.part(60,6);
#ifdef _DEBUG_DIGI_
cerr << "SSID :" << ssid << endl;
#endif
mdg.link_rtt[anzahl]=rtt_calc(laufzeit.part(0,laufzeit.slen()),flexnet);
#ifdef _DEBUG_DIGI_
cerr << "RTT:" << anzahl << ":" << mdg.link_rtt[anzahl] << endl;
#endif
mdg.gefundene_links++;
anzahl=digi_cfg.link_anzahl; //gefunden. Raus aus der Schleife
}
}
if (mdg.gefundene_links==digi_cfg.link_anzahl)
maske &= ~MASKE_LINK;
}
catch (Error_no_callsign)
{
}
}
}
}
void digi_interface::tnn_digi_line( String line )
{
last_activity = zeit();
double up = 0;
if ( maske & MASKE_DESTINATION )
{
if (line.in(String(" Active Nodes:")))
{
String dests;
dests=line.part(20,line.slen()-27);
mdg.destin = dests.Stoi();
maske &= ~MASKE_DESTINATION;
#ifdef _DEBUG_DIGI_
cerr << ">>" << mdg.destin << "<<" << endl;
#endif
}
}
if ( maske & MASKE_UPTIME )
{
if (line.in(String(" Uptime:")))
{
String Uptime;
int pos;
Uptime=line.part(20,line.slen()-20);
if ((pos=Uptime.pos("/"))) // 21/22:23
{
String Up;
Up=Uptime.part(0,pos);
up+=Up.Stoi()*24*60*60;
Up=Uptime.part(pos+1,2);
up+=Up.Stoi()*60*60;
Up=Uptime.part(pos+4,2);
up+=Up.Stoi()*60;
#ifdef _DEBUG_DIGI_
cerr << "Uptime: " << delta_t(up) << endl;
#endif
mdg.uptime=delta_t(up);
maske &= ~MASKE_UPTIME;
}
}
}
if ( maske & MASKE_LINK )
{
String Linkcall;
String hin, rueck;
String laufzeit;
String ssid;
if (line.slen()>50)
{
Linkcall=line.part(0,9);
try
{
for(int anzahl=0; anzahl<digi_cfg.link_anzahl; anzahl++)
{
//cerr << "Call:" << Linkcall <<":"<< digi_cfg.link_call[anzahl] << endl;
if (samecall(callsign(Linkcall),digi_cfg.link_call[anzahl]))
{
laufzeit=line.part(26,15);
// ssid=line.part(60,6);
//cerr << "SSID :" << ssid << endl;
mdg.link_rtt[anzahl]=rtt_calc(laufzeit.part(0,laufzeit.slen()),tnn);
#ifdef _DEBUG_DIGI_
cerr << "RTT:" << anzahl << ":" << mdg.link_rtt[anzahl] << endl;
#endif
mdg.gefundene_links++;
anzahl=digi_cfg.link_anzahl; //gefunden. Raus aus der Schleife
}
}
if (mdg.gefundene_links==digi_cfg.link_anzahl)
maske &= ~MASKE_LINK;
}
catch (Error_no_callsign)
{
}
}
}
}
void digi_interface::xnet_digi_line( String line )
{
last_activity = zeit();
double up = 0;
if ( maske & MASKE_DESTINATION )
{
if (line.in(String("destinations |")))
{
String dests;
dests=line.part(21,9);
#ifdef _DEBUG_DIGI_
cerr << "Dest >>" << dests << "<<" << endl;
#endif
mdg.destin = dests.Stoi();
maske &= ~MASKE_DESTINATION;
}
}
if ( maske & MASKE_NODES )
{
if (line.in(String("nodes |")))
{
String nodes;
nodes=line.part(21,9);
#ifdef _DEBUG_DIGI_
cerr << "Nodes >>" << nodes << "<<" << endl;
#endif
mdg.nodes = nodes.Stoi();
maske &= ~MASKE_NODES;
}
}
if ( maske & MASKE_UPTIME )
{
if (line.in(String("Uptime (")))
{
String Uptime;
String high, low;
Uptime=line.part(8,8);
low=Uptime.part(4,4);
high=Uptime.part(0,4);
#ifdef _DEBUG_DIGI_
cerr << ">>" << Uptime << "<<>>" << high << "<<>>" << low << "<<" << endl;
#endif
if (high.in("d"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*24*60*60;
}
if (high.in("h"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*60*60;
}
if (high.in("m"))
{
high.part(0,high.slen()-2); up+=high.Stoi()*60;
}
if (high.in("s"))
{
high.part(0,high.slen()-2); up=high.Stoi();
}
if (low.in("h"))
{
low.part(0,low.slen()-2); up+=low.Stoi()*60*60;
}
if (low.in("m"))
{
low.part(0,low.slen()-2); up+=low.Stoi()*60;
}
if (low.in("s"))
{
low.part(0,low.slen()-2); up+=low.Stoi();
}
#ifdef _DEBUG_DIGI_
cerr << "Uptime: " << delta_t(up) << endl;
#endif
mdg.uptime=delta_t(up);
maske &= ~MASKE_UPTIME;
}
}
if ( maske & MASKE_LINK )
{
String Linkcall;
String hin, rueck;
String laufzeit;
String ssid;
if (line.slen()>75)
{
Linkcall=line.part(3,9);
try
{
for(int anzahl=0; anzahl<digi_cfg.link_anzahl; anzahl++)
{
//cerr << "Call:" << digi_cfg.link_anzahl << digi_cfg.link_call[anzahl] << endl;
if (samecall(callsign(Linkcall),digi_cfg.link_call[anzahl]))
{
laufzeit=line.part(23,9);
// ssid=line.part(60,6);
//cerr << "SSID :" << ssid << endl;
mdg.link_rtt[anzahl]=rtt_calc(laufzeit.part(0,laufzeit.slen()),xnet);
#ifdef _DEBUG_DIGI_
cerr << "RTT:" << anzahl << ":" << mdg.link_rtt[anzahl] << endl;
#endif
mdg.gefundene_links++;
anzahl=digi_cfg.link_anzahl; //gefunden. Raus aus der Schleife
}
}
if (mdg.gefundene_links==digi_cfg.link_anzahl)
maske &= ~MASKE_LINK;
}
catch (Error_no_callsign)
{
}
}
}
}
String digi_interface::rtt_calc(String line, digi_typ typ)
{
String rtt=" --- ";
String hin, rueck;
int Hin=-2;
int Rueck=-2;
bool umleitung=false;
int pos1;
if (typ==flexnet)
{
#ifdef _DEBUG_DIGI_
cerr << "RTT-String:" << line << endl;
#endif
if (!line.in("/"))
{
if (line.in("-"))
return rtt;
else
{
Hin=line.Stoi();
if (Hin<10)
return (" "+itoS(Hin)+" ");
if (Hin<100)
return (" "+itoS(Hin)+" ");
if (Hin<1000)
return (" "+itoS(Hin)+" ");
return (itoS(Hin)+" ");
}
}
if((pos1=line.pos("/")))
{
hin=line.part(0,pos1);
rueck=line.part(pos1+1,line.slen()-pos1-1);
if (hin[0]==String("("))
{
umleitung=true;
hin=hin.part(1,hin.slen()-1);
rueck[line.pos("(")]=' ';
}
if (hin[0]==String("-"))
Hin=-1;
if (rueck[0]==String("-"))
Rueck=-1;
if (Hin!=-1 && Rueck!=-1)
{
Hin=hin.Stoi();
Rueck=rueck.Stoi();
}
if (Hin==-1 && Rueck==-1)
{
if (umleitung)
rtt="(-/-)";
else
rtt="--/--";
return rtt;
}
if (umleitung)
{
if(Hin>=999)
rtt="(*/";
else if (Hin>99)
rtt="(+/";
else if (Hin>9)
rtt="(./";
else
rtt="("+itoS(Hin)+"/";
}
else
{
if(Hin>=999)
{
Hin=Hin/1000;
rtt=itoS(Hin)+"*/";
}
else if (Hin>99)
{
Hin=Hin/100;
rtt=itoS(Hin)+"+/";
}
else if (Hin>9)
rtt=itoS(Hin)+"/";
else
rtt=" "+itoS(Hin)+"/";
}
if (umleitung)
{
if(Rueck>=999)
rtt.append("*)");
else if (Rueck>99)
rtt.append("+)");
else if (Rueck>9)
rtt.append(".)");
else
rtt.append(itoS(Rueck)+")");
}
else
{
if(Rueck>=999)
{
Rueck=Rueck/1000;
rtt.append(itoS(Rueck)+"*");
}
else if (Rueck>99)
{
Rueck=Rueck/100;
rtt.append(itoS(Rueck)+"+");
}
else if (Rueck>9)
rtt.append(itoS(Rueck));
else
rtt.append(itoS(Rueck)+" ");
}
}
}
else if (typ==tnn)
{
#ifdef _DEBUG_DIGI_
cerr << "RTT-String:" << line << endl;
#endif
if (!line.in("/"))
{
return rtt;
}
if((pos1=line.pos("/")))
{
hin=line.part(0,pos1);
rueck=line.part(pos1+1,line.slen()-pos1-1);
if (hin[hin.slen()-1]==String("-"))
Hin=-1;
if (rueck[0]==String("-"))
Rueck=-1;
if (Hin!=-1 && Rueck!=-1)
{
Hin=hin.Stoi();
Rueck=rueck.Stoi();
Hin/=100;
Rueck/=100;
}
if (Hin==-1 && Rueck==-1)
{
return ("--/--");
}
if(Hin>=999)
{
Hin=Hin/1000;
rtt=itoS(Hin)+"*/";
}
else if (Hin>99)
{
Hin=Hin/100;
rtt=itoS(Hin)+"+/";
}
else if (Hin>9)
rtt=itoS(Hin)+"/";
else
rtt=" "+itoS(Hin)+"/";
if(Rueck>=999)
{
Rueck=Rueck/1000;
rtt.append(itoS(Rueck)+"*");
}
else if (Rueck>99)
{
Rueck=Rueck/100;
rtt.append(itoS(Rueck)+"+");
}
else if (Rueck>9)
rtt.append(itoS(Rueck));
else
rtt.append(itoS(Rueck)+" ");
}
}
else if (typ==xnet)
{
#ifdef _DEBUG_DIGI_
cerr << "RTT-String:" << line << endl;
#endif
if (!line.in("/"))
{
if (line.in("-"))
return rtt;
else
{
Hin=line.Stoi();
if (Hin<10)
return (" "+itoS(Hin)+" ");
if (Hin<100)
return (" "+itoS(Hin)+" ");
if (Hin<1000)
return (" "+itoS(Hin)+" ");
return (itoS(Hin)+" ");
}
}
if((pos1=line.pos("/")))
{
hin=line.part(0,pos1);
rueck=line.part(pos1+1,line.slen()-pos1-1);
if (hin[hin.slen()-1]==String("-"))
Hin=-1;
if (rueck[0]==String("-"))
Rueck=-1;
if (Hin!=-1 && Rueck!=-1)
{
Hin=hin.Stoi();
Rueck=rueck.Stoi();
}
if (Hin==-1 && Rueck==-1)
{
return ("--/--");
}
if (Hin>99)
{
Hin=Hin/100;
rtt=itoS(Hin)+"+/";
}
else if (Hin>9)
rtt=itoS(Hin)+"/";
else
rtt=" "+itoS(Hin)+"/";
if (Rueck>99)
{
Rueck=Rueck/100;
rtt.append(itoS(Rueck)+"+");
}
else if (Rueck>9)
rtt.append(itoS(Rueck));
else
rtt.append(itoS(Rueck)+" ");
}
}
return rtt;
}
bool digi_control::set_slot( const callsign &call, int slt )
{
try
{
digi_config_file digicfg = digifiles.find(call);
digicfg.slot = slt;
if (digifiles.set(call,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
bool digi_control::set_pfad( const callsign &call, const connect_string &pfd )
{
try
{
digi_config_file digicfg = digifiles.find(call);
digicfg.pfad = pfd;
if (digifiles.set(call,digicfg))
{
digicfg.save();
return true;
}
return false;
}
catch( Error_unknown_digi )
{
return false;
}
}
void digi_control::enable( config_file &cfg )
{
cfg.set("DIGI_STATUS","JA");
cfg.save();
activ = true;
}
void digi_control::disable( config_file &cfg )
{
cfg.set("DIGI_STATUS","NEIN");
cfg.save();
activ = false;
}
| 22.688113 | 115 | 0.556891 | DF4IAH |
790b13872a46feaeb2cd735acc929f881e79b0b1 | 11,690 | cpp | C++ | Motor2D/Enemy.cpp | pink-king/Final-Fantasy-Tactics | b5dcdd0aa548900b3b2279cd4c6d4220f5869c08 | [
"Unlicense"
] | 9 | 2019-04-19T17:25:34.000Z | 2022-01-30T14:46:30.000Z | Motor2D/Enemy.cpp | pink-king/Final-Fantasy-Tactics | b5dcdd0aa548900b3b2279cd4c6d4220f5869c08 | [
"Unlicense"
] | 44 | 2019-03-22T10:22:19.000Z | 2019-08-08T07:48:27.000Z | Motor2D/Enemy.cpp | pink-king/Final-Fantasy-Tactics | b5dcdd0aa548900b3b2279cd4c6d4220f5869c08 | [
"Unlicense"
] | 1 | 2022-01-30T14:46:34.000Z | 2022-01-30T14:46:34.000Z | #include "Enemy.h"
#include "j1App.h"
#include "j1Render.h"
#include "j1EntityFactory.h"
#include "j1PathFinding.h"
#include "j1Map.h"
#include "j1Scene.h"
#include "WaveManager.h"
#include <ctime>
#include <random>
Enemy::Enemy(iPoint position, uint movementSpeed, uint detectionRange, uint attackRange, uint baseDamage, float attackSpeed, bool dummy, ENTITY_TYPE entityType, const char* name)
: speed(movementSpeed), detectionRange(detectionRange), baseDamage(baseDamage), attackRange(attackRange), dummy(dummy), attackSpeed(attackSpeed), j1Entity(entityType, position.x, position.y, name)
{
debugSubtile = App->entityFactory->debugsubtileTex;
// Intial orientation random
pointingDir = 1 + std::rand() % 8;
currentAnimation = &idle[pointingDir];
CheckRenderFlip();
this->attackPerS = 1.F / attackSpeed;
if (this->type != ENTITY_TYPE::ENEMY_DUMMY)
this->lifeBar = App->gui->AddHealthBarToEnemy(&App->gui->enemyLifeBarInfo.dynamicSection, type::enemy, this, App->scene->inGamePanel);
//App->audio->PlayFx(App->entityFactory->enemySpawn, 0);
}
Enemy::~Enemy()
{
App->attackManager->DestroyAllMyCurrentAttacks(this);
if (inWave)
{
std::vector<Enemy*>::iterator iter = App->entityFactory->waveManager->alive.begin();
for (; iter != App->entityFactory->waveManager->alive.end(); iter++)
{
if ((*iter) == this)
{
break;
}
}
App->entityFactory->waveManager->alive.erase(iter);
// Probably here will change the label of remaining enemies in the wave?
LOG("Enemies remaining: %i", App->entityFactory->waveManager->alive.size());
}
memset(idle, 0, sizeof(idle));
memset(run, 0, sizeof(run));
memset(basicAttack, 0, sizeof(basicAttack));
if (!App->cleaningUp) // When closing the App, Gui cpp already deletes the healthbar before this. Prevent invalid accesses
{
if (this->type != ENTITY_TYPE::ENEMY_DUMMY)
{
if (lifeBar != nullptr)
{
lifeBar->deliever = nullptr;
lifeBar->dynamicImage->to_delete = true; // deleted in uitemcpp draw
lifeBar->to_delete = true;
lifeBar->skull->to_delete = true;
}
}
LOG("parent enemy bye");
}
}
bool Enemy::SearchNewPath()
{
bool ret = false;
if (path_to_follow.empty() == false)
FreeMyReservedAdjacents();
path_to_follow.clear();
iPoint thisTile = App->map->WorldToMap((int)GetPivotPos().x, (int)GetPivotPos().y);
iPoint playerTile = App->map->WorldToMap((int)App->entityFactory->player->GetPivotPos().x, (int)App->entityFactory->player->GetPivotPos().y);
if (thisTile.DistanceManhattan(playerTile) > 1) // The enemy doesnt collapse with the player
{
if (App->pathfinding->CreatePath(thisTile, playerTile) > 0)
{
path_to_follow = *App->pathfinding->GetLastPath();
if (path_to_follow.size() > 1)
path_to_follow.erase(path_to_follow.begin()); // Enemy doesnt go to the center of his initial tile
if (path_to_follow.size() > 1)
path_to_follow.pop_back(); // Enemy doesnt eat the player, stays at 1 tile
//path_to_follow.pop_back();
ret = (path_to_follow.size() > 0);
}
//else LOG("Could not create path correctly");
}
return ret;
}
bool Enemy::SearchNewSubPath(bool ignoringColl) // Default -> path avoids other enemies
{
bool ret = false;
if (path_to_follow.empty() == false)
FreeMyReservedAdjacents();
path_to_follow.clear();
iPoint thisTile = App->map->WorldToSubtileMap((int)GetPivotPos().x, (int)GetPivotPos().y);
iPoint playerTile = App->entityFactory->player->GetSubtilePos();
if (thisTile.DistanceManhattan(playerTile) > 1) // The enemy doesnt collapse with the player
{
if (!ignoringColl)
{
if (App->pathfinding->CreateSubtilePath(thisTile, playerTile) > 0)
{
path_to_follow = *App->pathfinding->GetLastPath();
if (path_to_follow.size() > 1)
path_to_follow.erase(path_to_follow.begin()); // Enemy doesnt go to the center of his initial tile
if (path_to_follow.size() > 1)
path_to_follow.pop_back(); // Enemy doesnt eat the player, stays at 1 tile
iPoint adj = path_to_follow.back();
App->entityFactory->ReserveAdjacent(adj);
ret = (path_to_follow.size() > 0);
}
else LOG("Could not create path correctly");
}
else if(App->pathfinding->CreateSubtilePath(thisTile, playerTile, true) > 0)
{
path_to_follow = *App->pathfinding->GetLastPath();
if (path_to_follow.size() > 1)
path_to_follow.erase(path_to_follow.begin()); // Enemy doesnt go to the center of his initial tile
if (path_to_follow.size() > 1)
path_to_follow.pop_back(); // Enemy doesnt eat the player, stays at 1 tile
iPoint adj = path_to_follow.back();
App->entityFactory->ReserveAdjacent(adj);
ret = (path_to_follow.size() > 0);
}
else LOG("Could not create path correctly");
}
return ret;
}
bool Enemy::SearchPathToSubtile(const iPoint& goal)
{
bool ret = false;
if (path_to_follow.empty() == false)
FreeMyReservedAdjacents();
path_to_follow.clear();
if (imOnSubtile.DistanceManhattan(goal) > 1)
{
if (App->pathfinding->CreateSubtilePath(imOnSubtile, goal) > 0)
{
path_to_follow = *App->pathfinding->GetLastPath();
//if (path_to_follow.size() > 1)
// path_to_follow.erase(path_to_follow.begin()); // Enemy doesnt go to the center of his initial tile
//if (path_to_follow.size() > 1)
// path_to_follow.pop_back(); // Enemy doesnt eat the player, stays at 1 tile
/*iPoint adj = path_to_follow.back();
App->entityFactory->ReserveAdjacent(adj);*/
ret = (path_to_follow.size() > 0);
}
}
return ret;
}
int Enemy::GetRandomValue(const int& min, const int& max) const
{
static std::default_random_engine generator;
std::uniform_int_distribution<int> distribution(min, max);
float dice_roll = distribution(generator);
return dice_roll;
}
bool Enemy::isInDetectionRange() const
{
iPoint playerPos = App->entityFactory->player->GetTilePos();
return (GetTilePos().DistanceManhattan(playerPos) < detectionRange);
}
bool Enemy::isInAttackRange() const
{
return (GetSubtilePos().DistanceTo(App->entityFactory->player->GetSubtilePos()) <= attackRange);
}
bool Enemy::isNextPosFree(iPoint futurePos)
{
iPoint onSubtilePosTemp = App->map->WorldToSubtileMap(futurePos.x, futurePos.y);
return !(onSubtilePosTemp != previousSubtilePos && !App->entityFactory->isThisSubtileEnemyFree(onSubtilePosTemp));
}
bool Enemy::CheckFuturePos(float dt) const
{
fPoint tempPos = GetPivotPos() + velocity * dt * speed;
iPoint subtileTemp = App->map->WorldToSubtileMap(tempPos.x, tempPos.y);
return !(subtileTemp != previousSubtilePos && !App->entityFactory->isThisSubtileEnemyFree(subtileTemp));
}
bool Enemy::isOnDestiny() const
{
return GetPivotPos().DistanceTo(currentDestiny.Return_fPoint()) < 5;
}
void Enemy::FreeMyReservedAdjacents()
{
std::vector<iPoint>::iterator item = path_to_follow.begin();
for (; item != path_to_follow.end(); ++item)
{
if (App->entityFactory->isThisSubtileReserved(*item))
{
App->entityFactory->FreeAdjacent(*item);
break;
}
}
}
iPoint Enemy::SearchNeighbourSubtile() const
{
fPoint goal = position + velocity * speed * App->GetDt();
iPoint goalSubtile = App->map->WorldToSubtileMap(goal.ReturniPoint().x, goal.ReturniPoint().y);
iPoint neighbours[4];
neighbours[0] = goalSubtile + iPoint(1, 0);
neighbours[1] = goalSubtile + iPoint(0, 1);
neighbours[2] = goalSubtile + iPoint(-1, 0);
neighbours[3] = goalSubtile + iPoint(0, -1);
uint i = 0;
for (i; i <= 3; ++i)
{
if (App->entityFactory->isThisSubtileEnemyFree(neighbours[i]))
{
// This is the first free
return neighbours[i];
//SearchPathToSubtile(neighbours[i]);
break;
}
}
return iPoint(0, 0);
}
void Enemy::SetNewDirection()
{
velocity = currentDestiny.Return_fPoint() - GetPivotPos();
velocity.Normalize();
SetLookingTo(currentDestiny.Return_fPoint());
currentAnimation = &run[pointingDir];
}
void Enemy::MoveToCurrDestiny(float dt)
{
position += velocity * dt * speed;
}
int Enemy::GetPointingDir(float angle)
{
int numAnims = 8;
//LOG("angle: %f", angle);
// divide the semicircle in 4 portions
float animDistribution = PI / (numAnims * 0.5f); // each increment between portions //two semicircles
int i = 0;
if (angle >= 0) // is going right or on bottom semicircle range to left
{
// iterate between portions to find a match
for (float portion = animDistribution * 0.5f; portion <= PI; portion += animDistribution) // increment on portion units
{
if (portion >= angle) // if the portion is on angle range
{
// return the increment position matching with enumerator direction animation
// TODO: not the best workaround, instead do with std::map
/*LOG("bottom semicircle");
LOG("portion: %i", i);*/
break;
}
++i;
}
}
else if (angle <= 0) // animations relatives to upper semicircle
{
i = 0; // the next 4 on the enum direction
for (float portion = -animDistribution * 0.5f; portion >= -PI; portion -= animDistribution)
{
if (i == 1) i = numAnims * 0.5f + 1;
if (portion <= angle)
{
/*LOG("upper semicircle");
LOG("portion: %i", i);*/
break;
}
++i;
}
}
pointingDir = i;
if (pointingDir == numAnims) // if max direction
pointingDir = numAnims - 1; // set to prev
//LOG("portion: %i", pointingDir);
return pointingDir;
}
void Enemy::CheckRenderFlip()
{
if (pointingDir == int(facingDirection::SW) || pointingDir == 4 || pointingDir == 7)
{
flip = SDL_FLIP_HORIZONTAL;
}
else
flip = SDL_FLIP_NONE;
}
void Enemy::SetLookingTo(const fPoint& dir)
{
fPoint aux;
aux = dir - GetPivotPos();
aux.Normalize();
GetPointingDir(atan2f(aux.y, aux.x));
CheckRenderFlip();
}
void Enemy::DebugPath() const
{
for (uint i = 0; i < path_to_follow.size(); ++i)
{
if (!isSubpathRange) {
iPoint pos = App->map->MapToWorld(path_to_follow[i].x + 1, path_to_follow[i].y); // X + 1, Same problem with map
App->render->DrawQuad({ pos.x, pos.y + (int)(App->map->data.tile_height * 0.5F), 5, 5 }, 255 , 0, 255, 175, true);
//App->render->Blit(App->pathfinding->debug_texture, pos.x, pos.y);
}
else
{
iPoint pos = App->map->SubTileMapToWorld(path_to_follow[i].x + 1, path_to_follow[i].y); // X + 1, Same problem with map
App->render->DrawQuad({ pos.x, pos.y + (int)(App->map->data.tile_height * 0.5F * 0.5F), 3, 3 }, 255, 0, 255, 175, true);
//App->render->Blit(App->pathfinding->debug_texture, pos.x, pos.y);
}
}
iPoint subTilePos = GetSubtilePos();
subTilePos = App->map->SubTileMapToWorld(subTilePos.x, subTilePos.y);
App->render->Blit(debugSubtile, subTilePos.x, subTilePos.y, NULL);
// Real subtile?
//App->render->Blit(debugSubtile, subTilePos.x - 16, subTilePos.y - 8, NULL);
/*App->render->DrawQuad({ subTilePos.x, subTilePos.y, 5,5 }, 255, 255, 0, 255, true);
App->render->DrawIsoQuad({ subTilePos.x, subTilePos.y, 16, 16});*/
}
bool Enemy::Load(pugi::xml_node &)
{
return true;
}
bool Enemy::Save(pugi::xml_node &node) const
{
if(type == ENTITY_TYPE::ENEMY_BOMB)
node.append_attribute("type") = "enemyBomb";
else if(type == ENTITY_TYPE::ENEMY_TEST)
node.append_attribute("type") = "enemyTest";
node.append_attribute("level") = level;
node.append_attribute("life") = life;
pugi::xml_node nodeSpeed = node.append_child("position");
nodeSpeed.append_attribute("x") = position.x;
nodeSpeed.append_attribute("y") = position.y;
return true;
}
void Enemy::Draw()
{
if(App->scene->debugSubtiles == true)
DebugPath();
if (entityTex != nullptr)
{
if (currentAnimation != nullptr)
App->render->Blit(entityTex, position.x, position.y, ¤tAnimation->GetCurrentFrame(), 1.0F, flip);
else
App->render->Blit(entityTex, position.x, position.y);
}
}
| 28.651961 | 198 | 0.688537 | pink-king |
790b79670bda81a9c4bf639db26d4642f0963209 | 847 | cpp | C++ | src/easteregg.cpp | CodeScratcher/shimmerlang | 2137b3b11574d6b378aff8df7a3342c1a0915964 | [
"MIT"
] | null | null | null | src/easteregg.cpp | CodeScratcher/shimmerlang | 2137b3b11574d6b378aff8df7a3342c1a0915964 | [
"MIT"
] | 3 | 2020-10-29T21:02:49.000Z | 2021-06-14T19:40:36.000Z | src/easteregg.cpp | CodeScratcher/shimmerlang | 2137b3b11574d6b378aff8df7a3342c1a0915964 | [
"MIT"
] | null | null | null | #include <string>
#include "easteregg.h"
std::string get_easteregg(int n) {
return (
"\x1b[1;93m"
R"( )" "\n"
R"( LOL MEMES . . WOW FTLULZ )" "\n"
R"( XD ____ __ .*\.* SUCH COOL MUCH )" "\n"
R"( / ___\ / / */.*. MANY NICE ____ BORED )" "\n"
R"( / /_ / /_ :) __ ______ ______ / __ \ ___ )" "\n"
R"( \__ \ / __ \ / / / \ / \ / ____/ / __\ )" "\n"
R"( ____/ / / / / / / / / // // / / // // / / /___aste/ / )" "\n"
R"( \____/ /_/ /_/ /_/ /_//_//_/ /_//_//_/ \____/ /_/ egg )" "\n"
R"( ===============================================---====== )" "\n"
"\x1b[0m"
);
}
| 42.35 | 79 | 0.250295 | CodeScratcher |
790d4dbebc90149c98b63fbfb10a26e7249295a7 | 263 | hpp | C++ | packets/PKT_S2C_DisableHUDForEndOfGame.hpp | HoDANG/OGLeague2 | 21efea8ea480972a6d686c4adefea03d57da5e9d | [
"MIT"
] | 1 | 2022-03-27T10:21:41.000Z | 2022-03-27T10:21:41.000Z | packets/PKT_S2C_DisableHUDForEndOfGame.hpp | HoDANG/OGLeague2 | 21efea8ea480972a6d686c4adefea03d57da5e9d | [
"MIT"
] | null | null | null | packets/PKT_S2C_DisableHUDForEndOfGame.hpp | HoDANG/OGLeague2 | 21efea8ea480972a6d686c4adefea03d57da5e9d | [
"MIT"
] | 3 | 2019-07-20T03:59:10.000Z | 2022-03-27T10:20:09.000Z | #ifndef HPP_180_PKT_S2C_DisableHUDForEndOfGame_HPP
#define HPP_180_PKT_S2C_DisableHUDForEndOfGame_HPP
#include "base.hpp"
#pragma pack(push, 1)
struct PKT_S2C_DisableHUDForEndOfGame_s : DefaultPacket<PKT_S2C_DisableHUDForEndOfGame>
{
};
#pragma pack(pop)
#endif | 23.909091 | 87 | 0.851711 | HoDANG |
790e65c360fc6ee18ec420955ee97c3fcf36933b | 1,091 | cpp | C++ | src/dblp/index/models/match/index_match.cpp | Docheinstein/dblp-searcher | e7bb458c39cab35a40c525fefe206bb768253c35 | [
"MIT"
] | null | null | null | src/dblp/index/models/match/index_match.cpp | Docheinstein/dblp-searcher | e7bb458c39cab35a40c525fefe206bb768253c35 | [
"MIT"
] | null | null | null | src/dblp/index/models/match/index_match.cpp | Docheinstein/dblp-searcher | e7bb458c39cab35a40c525fefe206bb768253c35 | [
"MIT"
] | null | null | null | #include "index_match.h"
#include "commons/globals/globals.h"
IndexMatch::operator QString() const
{
QString s;
s += "-- INDEX MATCH --\n";
s += "Serial: " + DEC(elementSerial) + "\n";
s += "Match pos: " + DEC(matchPosition) + "\n";
s += "Field num: " + DEC(fieldNumber) + "\n";
s += "Field type: " + elementFieldTypeString(fieldType) + "\n";
int i = 1;
for (const QString &matchedToken : matchedTokens) {
s += DEC(i) + ". matched token: " + matchedToken + "\n";
++i;
}
return s;
}
bool operator==(const IndexMatch &efm1, const IndexMatch &efm2) {
return
efm1.elementSerial == efm2.elementSerial &&
efm1.fieldType == efm2.fieldType &&
efm1.fieldNumber == efm2.fieldNumber &&
efm1.matchPosition == efm2.matchPosition;
}
uint qHash(const IndexMatch &efm) {
static quint32 SERIAL_ENLARGER =
UINT_MAX / Config::Index::PostingList::ELEMENT_SERIAL_THRESHOLD;
return qHash(efm.elementSerial * SERIAL_ENLARGER) ^
UINT32(((17506 + efm.fieldNumber) * 0x45d9f3b) << 16) ^
UINT32(((8868 + efm.matchPosition) * 0x44c923b) << 8) ^
UINT32(efm.fieldType);
}
| 26.609756 | 67 | 0.658112 | Docheinstein |
790ecd27034330df97129d53197f2f617fcaf44d | 5,381 | cpp | C++ | Source/Desert.cpp | michal-z/Desert | 845a7f5f7b1927f6716c37fb3aa0bbe71645d49b | [
"MIT"
] | 1 | 2021-11-07T07:22:40.000Z | 2021-11-07T07:22:40.000Z | Source/Desert.cpp | michal-z/Desert | 845a7f5f7b1927f6716c37fb3aa0bbe71645d49b | [
"MIT"
] | null | null | null | Source/Desert.cpp | michal-z/Desert | 845a7f5f7b1927f6716c37fb3aa0bbe71645d49b | [
"MIT"
] | null | null | null | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define GLFW_INCLUDE_GLCOREARB
#include <GLFW/glfw3.h>
#define IMAGE_WIDTH 1280
#define IMAGE_HEIGHT 720
static PFNGLCREATEVERTEXARRAYSPROC glCreateVertexArrays;
static PFNGLCREATEPROGRAMPIPELINESPROC glCreateProgramPipelines;
static PFNGLCREATESHADERPROGRAMVPROC glCreateShaderProgramv;
static PFNGLCREATETEXTURESPROC glCreateTextures;
static PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
static PFNGLDELETEPROGRAMPIPELINESPROC glDeleteProgramPipelines;
static PFNGLDELETEPROGRAMPROC glDeleteProgram;
static PFNGLDELETETEXTURESPROC glDeleteTextures;
static PFNGLUSEPROGRAMSTAGESPROC glUseProgramStages;
static PFNGLBINDPROGRAMPIPELINEPROC glBindProgramPipeline;
static PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
static PFNGLDRAWARRAYSPROC glDrawArrays;
static PFNGLDISPATCHCOMPUTEPROC glDispatchCompute;
static PFNGLTEXTURESTORAGE2DPROC glTextureStorage2D;
static PFNGLTEXTUREPARAMETERIPROC glTextureParameteri;
static PFNGLBINDTEXTUREUNITPROC glBindTextureUnit;
static PFNGLBINDIMAGETEXTUREPROC glBindImageTexture;
static uint32_t s_Vs;
static uint32_t s_Fs;
static uint32_t s_Vao;
static uint32_t s_Ppo;
static uint32_t s_Tex;
bool ShouldRecompileShaders();
static char*
LoadTextFile(const char* fileName)
{
FILE* file = fopen(fileName, "rb");
assert(file);
fseek(file, 0, SEEK_END);
long size = ftell(file);
assert(size != -1);
char* content = (char*)malloc(size + 1);
assert(content);
fseek(file, 0, SEEK_SET);
fread(content, 1, size, file);
fclose(file);
content[size] = '\0';
return content;
}
static void
CreateShaders()
{
glDeleteProgram(s_Vs);
glDeleteProgram(s_Fs);
char *glsl = LoadTextFile("Desert.glsl");
const char *vsSrc[] = { "#version 450 core\n", "#define VS_FULL_TRIANGLE\n", (const char *)glsl };
s_Vs = glCreateShaderProgramv(GL_VERTEX_SHADER, 3, vsSrc);
const char *fsSrc[] = { "#version 450 core\n", "#define FS_DESERT\n", (const char *)glsl };
s_Fs = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 3, fsSrc);
free(glsl);
glUseProgramStages(s_Ppo, GL_VERTEX_SHADER_BIT, s_Vs);
glUseProgramStages(s_Ppo, GL_FRAGMENT_SHADER_BIT, s_Fs);
}
static void
Initialize()
{
glCreateVertexArrays(1, &s_Vao);
glCreateProgramPipelines(1, &s_Ppo);
glCreateTextures(GL_TEXTURE_2D, 1, &s_Tex);
glTextureParameteri(s_Tex, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(s_Tex, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTextureStorage2D(s_Tex, 1, IMAGE_WIDTH, IMAGE_HEIGHT, GL_RGBA8);
CreateShaders();
}
static void
Shutdown()
{
glDeleteProgram(s_Vs);
glDeleteProgram(s_Fs);
glDeleteProgramPipelines(1, &s_Ppo);
glDeleteVertexArrays(1, &s_Vao);
glfwTerminate();
}
static void
Update()
{
glBindProgramPipeline(s_Ppo);
glBindVertexArray(s_Vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
if (ShouldRecompileShaders())
{
CreateShaders();
}
}
int
main()
{
if (!glfwInit())
{
return 1;
}
glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);
glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
GLFWwindow *window = glfwCreateWindow(IMAGE_WIDTH, IMAGE_HEIGHT, "Desert", NULL, NULL);
if (!window)
{
glfwTerminate();
return 2;
}
glfwMakeContextCurrent(window);
glCreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC)glfwGetProcAddress("glCreateVertexArrays");
glCreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC)glfwGetProcAddress("glCreateProgramPipelines");
glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glfwGetProcAddress("glCreateShaderProgramv");
glCreateTextures = (PFNGLCREATETEXTURESPROC)glfwGetProcAddress("glCreateTextures");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArrays");
glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glfwGetProcAddress("glDeleteProgramPipelines");
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glfwGetProcAddress("glDeleteProgram");
glDeleteTextures = (PFNGLDELETETEXTURESPROC)glfwGetProcAddress("glDeleteTextures");
glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glfwGetProcAddress("glUseProgramStages");
glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glfwGetProcAddress("glBindProgramPipeline");
glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArray");
glDrawArrays = (PFNGLDRAWARRAYSPROC)glfwGetProcAddress("glDrawArrays");
glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)glfwGetProcAddress("glDispatchCompute");
glTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC)glfwGetProcAddress("glTextureStorage2D");
glTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC)glfwGetProcAddress("glTextureParameteri");
glBindTextureUnit = (PFNGLBINDTEXTUREUNITPROC)glfwGetProcAddress("glBindTextureUnit");
glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glfwGetProcAddress("glBindImageTexture");
Initialize();
while (!glfwWindowShouldClose(window))
{
Update();
glfwSwapBuffers(window);
glfwPollEvents();
}
Shutdown();
return 0;
}
| 33.01227 | 111 | 0.773091 | michal-z |
791034bc1e0f89557bbc5aab3358df5d200cca68 | 1,832 | cpp | C++ | tggdkjxv/State.Statistics.cpp | playdeezgames/tggdkjxv | bdb1a31ffff2dd3b3524de4639846fa902b893b9 | [
"MIT"
] | null | null | null | tggdkjxv/State.Statistics.cpp | playdeezgames/tggdkjxv | bdb1a31ffff2dd3b3524de4639846fa902b893b9 | [
"MIT"
] | null | null | null | tggdkjxv/State.Statistics.cpp | playdeezgames/tggdkjxv | bdb1a31ffff2dd3b3524de4639846fa902b893b9 | [
"MIT"
] | null | null | null | #include "Application.Renderer.h"
#include "Application.Command.h"
#include "Application.MouseButtonUp.h"
#include "Application.OnEnter.h"
#include "Game.Audio.Mux.h"
#include "Game.Achievements.h"
#include "Visuals.Texts.h"
#include <format>
#include "Common.Utility.h"
#include <tuple>
namespace state::Statistics
{
const std::string LAYOUT_NAME = "State.Statistics";
const std::string TEXT_MOVES_MADE = "MovesMade";
const std::string TEXT_GAMES_PLAYED = "GamesPlayed";
static bool OnMouseButtonUp(const common::XY<int>& xy, unsigned char buttons)
{
::application::UIState::Write(::UIState::MAIN_MENU);
return true;
}
static void SetStatisticText(const std::string& textId, const std::string& caption, const game::Statistic& statistic)
{
auto value = game::Statistics::Read(statistic);
if (value)
{
visuals::Texts::SetText(LAYOUT_NAME, textId, std::format("{}: {}", caption, value.value()));
}
else
{
visuals::Texts::SetText(LAYOUT_NAME, textId, std::format("{}: -", caption));
}
}
const std::vector<std::tuple<std::string, std::string, game::Statistic>> statisticsList =
{
{ TEXT_MOVES_MADE, "Moves Made", game::Statistic::MOVES_MADE},
{ TEXT_GAMES_PLAYED, "Games Played", game::Statistic::GAMES_PLAYED}
};
static void OnEnter()
{
game::audio::Mux::Play(game::audio::Mux::Theme::MAIN);
for (auto& item : statisticsList)
{
SetStatisticText(std::get<0>(item), std::get<1>(item), std::get<2>(item));
}
}
void Start()
{
::application::OnEnter::AddHandler(::UIState::STATISTICS, OnEnter);
::application::MouseButtonUp::AddHandler(::UIState::STATISTICS, OnMouseButtonUp);
::application::Command::SetHandler(::UIState::STATISTICS, ::application::UIState::GoTo(::UIState::MAIN_MENU));
::application::Renderer::SetRenderLayout(::UIState::STATISTICS, LAYOUT_NAME);
}
}
| 31.050847 | 118 | 0.708515 | playdeezgames |
79119636105a12278d7b0567946a2d866fe025ee | 3,010 | hpp | C++ | common-utilities/libs/math/tests/testStatistics/testLinearLeastSquaresFitting.hpp | crdrisko/drychem | 15de97f277a836fb0bfb34ac6489fbc037b5151f | [
"MIT"
] | 1 | 2020-09-26T12:38:54.000Z | 2020-09-26T12:38:54.000Z | common-utilities/libs/math/tests/testStatistics/testLinearLeastSquaresFitting.hpp | crdrisko/cpp-units | 15de97f277a836fb0bfb34ac6489fbc037b5151f | [
"MIT"
] | 9 | 2020-10-05T12:53:12.000Z | 2020-11-02T19:28:01.000Z | common-utilities/libs/math/tests/testStatistics/testLinearLeastSquaresFitting.hpp | crdrisko/cpp-units | 15de97f277a836fb0bfb34ac6489fbc037b5151f | [
"MIT"
] | 1 | 2020-12-04T13:34:41.000Z | 2020-12-04T13:34:41.000Z | // Copyright (c) 2020-2021 Cody R. Drisko. All rights reserved.
// Licensed under the MIT License. See the LICENSE file in the project root for more information.
//
// Name: testLinearLeastSquaresFitting.hpp
// Author: crdrisko
// Date: 10/26/2020-11:56:41
// Description: Provides ~100% unit test coverage over the linear least squares fitting function
#ifndef DRYCHEM_COMMON_UTILITIES_LIBS_MATH_TESTS_TESTSTATISTICS_TESTLINEARLEASTSQUARESFITTING_HPP
#define DRYCHEM_COMMON_UTILITIES_LIBS_MATH_TESTS_TESTSTATISTICS_TESTLINEARLEASTSQUARESFITTING_HPP
#include <cmath>
#include <sstream>
#include <vector>
#include <common-utils/math.hpp>
#include <gtest/gtest.h>
GTEST_TEST(testLinearLeastSquaresFitting, linearLeastSquaresFittingReturnsMultipleValuesInAStruct)
{
std::vector<long double> x {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
std::vector<long double> y {2.0, 5.0, 3.0, 7.0, 8.0, 9.0, 12.0, 10.0, 15.0, 20.0};
CppUtils::Math::details::LinearLeastSquaresResult<long double> result
= DryChem::linearLeastSquaresFitting(x.begin(), x.end(), y.begin(), y.end());
ASSERT_NEAR(1.7152, result.slope, DryChem::findAbsoluteError(1.7152, 5));
ASSERT_NEAR(-0.33333, result.intercept, DryChem::findAbsoluteError(-0.33333, 5));
ASSERT_NEAR(0.2139317, std::sqrt(result.variance), DryChem::findAbsoluteError(0.2139317, 7));
}
GTEST_TEST(testLinearLeastSquaresFitting, linearLeastSquaresFittingCanReturnATypeCompatibleWithStructuredBinding)
{
std::vector<long double> x {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
std::vector<long double> y {2.0, 5.0, 3.0, 7.0, 8.0, 9.0, 12.0, 10.0, 15.0, 20.0};
auto [slope, intercept, variance] = DryChem::linearLeastSquaresFitting(x.cbegin(), x.cend(), y.cbegin(), y.cend());
ASSERT_NEAR(1.7152, slope, DryChem::findAbsoluteError(1.7152, 5));
ASSERT_NEAR(-0.33333, intercept, DryChem::findAbsoluteError(-0.33333, 5));
ASSERT_NEAR(0.2139317, std::sqrt(variance), DryChem::findAbsoluteError(0.2139317, 7));
}
GTEST_TEST(testLinearLeastSquaresFitting, passingTwoDifferentlySizedContainersResultsInFatalException)
{
std::stringstream deathRegex;
deathRegex << "Common-Utilities Fatal Error: ";
#if GTEST_USES_POSIX_RE
deathRegex << "[(]linearLeastSquaresFitting.hpp: *[0-9]*[)]\n\t";
#elif GTEST_USES_SIMPLE_RE
deathRegex << "\\(linearLeastSquaresFitting.hpp: \\d*\\)\n\t";
#endif
deathRegex << "Input sizes for x and y containers must be the same.\n";
std::vector<long double> x {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
std::vector<long double> y {2.0, 5.0, 3.0, 7.0, 8.0, 9.0, 12.0, 10.0, 15.0, 20.0};
ASSERT_DEATH(
{
try
{
DryChem::linearLeastSquaresFitting(x.begin(), x.end(), y.begin(), y.end() - 2);
}
catch (const DryChem::InputSizeMismatch& except)
{
except.handleErrorWithMessage();
}
},
deathRegex.str());
}
#endif
| 39.605263 | 119 | 0.683389 | crdrisko |
79156c92a9f526a43c4ce31b21ba9cadadf8ba95 | 1,892 | cpp | C++ | leetcode/problems/hard/927-three-equal-parts.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | 18 | 2020-08-27T05:27:50.000Z | 2022-03-08T02:56:48.000Z | leetcode/problems/hard/927-three-equal-parts.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | null | null | null | leetcode/problems/hard/927-three-equal-parts.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | 1 | 2020-10-13T05:23:58.000Z | 2020-10-13T05:23:58.000Z | /*
Three Equal Parts
https://leetcode.com/problems/three-equal-parts/
You are given an array arr which consists of only zeros and ones, divide the array into three non-empty parts such that all of these parts represent the same binary value.
If it is possible, return any [i, j] with i + 1 < j, such that:
arr[0], arr[1], ..., arr[i] is the first part,
arr[i + 1], arr[i + 2], ..., arr[j - 1] is the second part, and
arr[j], arr[j + 1], ..., arr[arr.length - 1] is the third part.
All three parts have equal binary values.
If it is not possible, return [-1, -1].
Note that the entire part is used when considering what binary value it represents. For example, [1,1,0] represents 6 in decimal, not 3. Also, leading zeros are allowed, so [0,1,1] and [1,1] represent the same value.
Example 1:
Input: arr = [1,0,1,0,1]
Output: [0,3]
Example 2:
Input: arr = [1,1,0,1,1]
Output: [-1,-1]
Example 3:
Input: arr = [1,1,0,0,1]
Output: [0,2]
Constraints:
3 <= arr.length <= 3 * 104
arr[i] is 0 or 1
*/
class Solution {
public:
int find_first_one(vector<int>& arr, int target) {
int cnt = 0;
for(int i = 0; i < arr.size(); i++) {
if(arr[i] == 1) cnt++;
if(cnt == target) return i;
}
return -1;
}
vector<int> threeEqualParts(vector<int>& arr) {
int one = count(arr.begin(), arr.end(), 1);
if(one % 3 != 0) return vector<int>{-1, -1};
int one_per_part = one / 3;
if(one_per_part == 0) return vector<int>{0, (int)arr.size() - 1};
int l = find_first_one(arr, 1);
int m = find_first_one(arr, one_per_part + 1);
int r = find_first_one(arr, 2 * one_per_part + 1);
while(r < arr.size()) {
if(arr[l] == arr[m] && arr[m] == arr[r]) l++, m++, r++;
else return vector<int>{-1, -1};
}
return vector<int>{l - 1, m};
}
}; | 29.5625 | 216 | 0.580338 | wingkwong |
7918ee6337bc9461547cc96bbcde4d6e754bf9f2 | 5,738 | cc | C++ | orttraining/orttraining/test/training_ops/cuda/view_op_test.cc | dennyac/onnxruntime | d5175795d2b7f2db18b0390f394a49238f814668 | [
"MIT"
] | 6,036 | 2019-05-07T06:03:57.000Z | 2022-03-31T17:59:54.000Z | orttraining/orttraining/test/training_ops/cuda/view_op_test.cc | dennyac/onnxruntime | d5175795d2b7f2db18b0390f394a49238f814668 | [
"MIT"
] | 5,730 | 2019-05-06T23:04:55.000Z | 2022-03-31T23:55:56.000Z | orttraining/orttraining/test/training_ops/cuda/view_op_test.cc | dennyac/onnxruntime | d5175795d2b7f2db18b0390f394a49238f814668 | [
"MIT"
] | 1,566 | 2019-05-07T01:30:07.000Z | 2022-03-31T17:06:50.000Z | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "gtest/gtest.h"
#include "test/providers/provider_test_utils.h"
namespace onnxruntime {
namespace test {
template <class T>
using ShapeAndData = std::pair<const std::vector<int64_t>, const std::vector<T>>;
using ShapeAndFloatData = ShapeAndData<float>;
using ShapeAndDoubleData = ShapeAndData<double>;
using ShapeAndHalfData = ShapeAndData<MLFloat16>;
using ShapeData = ShapeAndData<int64_t>;
using ExpectResult = OpTester::ExpectResult;
template <typename T>
void RunTest(const ShapeAndData<T>& input,
const std::vector<ShapeData>& shapes,
const std::vector<ShapeAndData<T>>& outputs,
bool expect_failure = false,
const std::string& err_msg = {}) {
OpTester test("View", 1, onnxruntime::kMSDomain);
test.AddInput<T>("input0", input.first, input.second);
int i = 1;
for (auto& s : shapes) {
auto& shape = s.first;
auto& data = s.second;
std::ostringstream oss;
oss << "input" << i++;
test.AddInput<int64_t>(oss.str().c_str(), shape, data);
}
i = 0;
for (auto& output : outputs) {
auto& shape = output.first;
auto& data = output.second;
std::ostringstream oss;
oss << "output" << i++;
test.AddOutput<T>(oss.str().c_str(), shape, data);
}
std::unordered_set<std::string> excluded_providers;
test.Run(expect_failure ? ExpectResult::kExpectFailure : ExpectResult::kExpectSuccess, err_msg, excluded_providers);
}
TEST(ViewOperatorTest, TwoViewFloat_1) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndFloatData> outputs;
// input shape and data
ShapeAndFloatData input = {{4, 2},
{1.f, 2.f,
3.f, 4.f,
5.f, 6.f,
7.f, 8.f}};
shapes.push_back({{2}, std::vector<int64_t>(2, 2)});
shapes.push_back({{2}, std::vector<int64_t>(2, 2)});
outputs.push_back({{2, 2},
{1.f, 2.f,
3.f, 4.f}});
outputs.push_back({{2, 2},
{5.f, 6.f,
7.f, 8.f}});
RunTest<float>(input, shapes, outputs);
}
TEST(ViewOperatorTest, TwoViewFloat_2) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndFloatData> outputs;
// input shape and data
ShapeAndFloatData input = {{4, 2},
{1.f, 2.f,
3.f, 4.f,
5.f, 6.f,
7.f, 8.f}};
shapes.push_back({{2}, {1, 2}});
shapes.push_back({{2}, {3, 2}});
outputs.push_back({{1, 2}, {1.f, 2.f}});
outputs.push_back({{3, 2},
{3.f, 4.f,
5.f, 6.f,
7.f, 8.f}});
RunTest<float>(input, shapes, outputs);
}
TEST(ViewOperatorTest, TwoViewFloat_3) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndFloatData> outputs;
// input shape and data
ShapeAndFloatData input = {{4, 2},
{1.f, 2.f,
3.f, 4.f,
5.f, 6.f,
7.f, 8.f}};
shapes.push_back({{2}, {1, 2}});
shapes.push_back({{3}, {1, 3, 2}});
outputs.push_back({{1, 2}, {1.f, 2.f}});
outputs.push_back({{1, 3, 2},
{3.f, 4.f,
5.f, 6.f,
7.f, 8.f}});
RunTest<float>(input, shapes, outputs);
}
TEST(ViewOperatorTest, ThreeViewFloat) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndFloatData> outputs;
// input shape and data
ShapeAndFloatData input = {{4, 3},
{1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
7.f, 8.f, 9.f, 10.f, 11.f, 12.f}};
shapes.push_back({{2}, {1, 2}});
shapes.push_back({{3}, {1, 3, 2}});
shapes.push_back({{2}, {4, 1}});
outputs.push_back({{1, 2}, {1.f, 2.f}});
outputs.push_back({{1, 3, 2},
{3.f, 4.f, 5.f, 6.f, 7.f, 8.f}});
outputs.push_back({{4, 1},
{9.f, 10.f, 11.f, 12.f}});
RunTest<float>(input, shapes, outputs);
}
TEST(ViewOperatorTest, TwoViewDouble) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndDoubleData> outputs;
// input shape and data
ShapeAndDoubleData input = {{3, 2},
{1.f, 2.f,
3.f, 4.f,
5.f, 6.f}};
shapes.push_back({{2}, {2, 1}});
shapes.push_back({{3}, {1, 2, 2}});
outputs.push_back({{2, 1},
{1.f, 2.f}});
outputs.push_back({{1, 2, 2},
{3.f, 4.f, 5.f, 6.f}});
RunTest<double>(input, shapes, outputs);
}
TEST(ViewOperatorTest, TwoViewHalf) {
std::vector<ShapeData> shapes;
std::vector<ShapeAndHalfData> outputs;
std::vector<float> data = {1.0f, 2.0f,
3.0f, 4.0f,
5.0f, 6.0f};
std::vector<MLFloat16> data_half(6);
ConvertFloatToMLFloat16(data.data(), data_half.data(), 6);
// input shape and data
ShapeAndHalfData input = {{3, 2}, data_half};
shapes.push_back({{2}, {2, 1}});
shapes.push_back({{3}, {1, 2, 2}});
std::vector<float> data1 = {1.0f, 2.0f};
std::vector<MLFloat16> data_half1(2);
ConvertFloatToMLFloat16(data1.data(), data_half1.data(), 2);
outputs.push_back({{2, 1}, data_half1});
std::vector<float> data2 = {3.f, 4.f, 5.f, 6.f};
std::vector<MLFloat16> data_half2(4);
ConvertFloatToMLFloat16(data2.data(), data_half2.data(), 4);
outputs.push_back({{1, 2, 2}, data_half2});
RunTest<MLFloat16>(input, shapes, outputs);
}
} // namespace test
} // namespace onnxruntime
| 29.27551 | 118 | 0.53625 | dennyac |
79192d1f04187699001026491d2ab05848f3fe60 | 1,838 | cpp | C++ | tests/count_pointer.cpp | zzxx-husky/ZAF | b9c37c758a2f8242aec0d70c467d718468d08fa5 | [
"Apache-2.0"
] | 4 | 2021-07-29T12:49:09.000Z | 2022-01-13T03:40:46.000Z | tests/count_pointer.cpp | zzxx-husky/ZAF | b9c37c758a2f8242aec0d70c467d718468d08fa5 | [
"Apache-2.0"
] | null | null | null | tests/count_pointer.cpp | zzxx-husky/ZAF | b9c37c758a2f8242aec0d70c467d718468d08fa5 | [
"Apache-2.0"
] | null | null | null | #include "zaf/count_pointer.hpp"
#include "gtest/gtest.h"
namespace zaf {
GTEST_TEST(CountPointer, NullPointer) {
CountPointer<int> pointer = nullptr;
}
GTEST_TEST(CountPointer, CopyAndMove) {
auto a = make_count<int>(-1);
{
a = a;
EXPECT_EQ(*a, -1);
}
{
a = std::move(a);
EXPECT_EQ(*a, -1);
}
{
auto b = std::move(a);
EXPECT_FALSE(bool(a));
EXPECT_TRUE(bool(b));
EXPECT_EQ(*b, -1);
}
}
GTEST_TEST(CountPointer, Assignment) {
auto a = make_count<int>(-1);
auto b = a;
EXPECT_EQ(-1, *b);
CountPointer<int> c;
{
auto x = make_count<int>(2);
c = x;
}
EXPECT_EQ(*CountPointer<int>(c), 2);
}
namespace internal {
class CountPointerClass {
public:
static unsigned count;
CountPointerClass() {
++count;
}
CountPointerClass(const CountPointerClass &) {
++count;
}
CountPointerClass(CountPointerClass &&) {
++count;
}
~CountPointerClass() {
--count;
}
};
unsigned CountPointerClass::count = 0;
}
GTEST_TEST(CountPointer, CustomizedClass) {
auto a = make_count<internal::CountPointerClass>(internal::CountPointerClass());
EXPECT_EQ(1, internal::CountPointerClass::count);
a = nullptr;
EXPECT_EQ(0, internal::CountPointerClass::count);
a = make_count<internal::CountPointerClass>(internal::CountPointerClass());
auto b = a;
EXPECT_EQ(1, internal::CountPointerClass::count);
auto c = b;
EXPECT_EQ(1, internal::CountPointerClass::count);
b = make_count<internal::CountPointerClass>(internal::CountPointerClass());
EXPECT_EQ(2, internal::CountPointerClass::count);
a = make_count<internal::CountPointerClass>(internal::CountPointerClass());
EXPECT_EQ(3, internal::CountPointerClass::count);
c = nullptr;
a = nullptr;
b = nullptr;
EXPECT_EQ(0, internal::CountPointerClass::count);
}
} // namespace zaf
| 21.126437 | 82 | 0.671382 | zzxx-husky |
7919d493ae95ee0cae18e1b5222c4dcb2d338549 | 552 | cpp | C++ | source/chapter_02/listings/listing_02_05_ourfunc.cpp | ShinyGreenRobot/CPP-Primer-Plus-Sixth-Edition | ce2c8fca379508929dfd24dce10eff2c09117999 | [
"MIT"
] | null | null | null | source/chapter_02/listings/listing_02_05_ourfunc.cpp | ShinyGreenRobot/CPP-Primer-Plus-Sixth-Edition | ce2c8fca379508929dfd24dce10eff2c09117999 | [
"MIT"
] | null | null | null | source/chapter_02/listings/listing_02_05_ourfunc.cpp | ShinyGreenRobot/CPP-Primer-Plus-Sixth-Edition | ce2c8fca379508929dfd24dce10eff2c09117999 | [
"MIT"
] | null | null | null | /**
* \file
* listing_02_05_ourfunc.cpp
*
* \brief
* Defining your own function.
*/
#include <iostream>
void simon(int);
int main()
{
using namespace std;
simon(3); // call the simon() function
cout << "Pick an integer: ";
int count;
cin >> count;
simon(count); // call the simon() function again
cout << "Done!" << endl;
return 0;
}
void simon(int n) // define the simon() function
{
using namespace std;
cout << "Simon says touch your toes " << n << " times." << endl;
// void functions does not need return statements
}
| 16.727273 | 65 | 0.630435 | ShinyGreenRobot |
791ac7f503b56b6360f58bc778d10cfddcf063a4 | 978 | cpp | C++ | data/transcoder_evaluation_gfg/cpp/COUNT_BINARY_DIGIT_NUMBERS_SMALLER_N.cpp | mxl1n/CodeGen | e5101dd5c5e9c3720c70c80f78b18f13e118335a | [
"MIT"
] | 241 | 2021-07-20T08:35:20.000Z | 2022-03-31T02:39:08.000Z | data/transcoder_evaluation_gfg/cpp/COUNT_BINARY_DIGIT_NUMBERS_SMALLER_N.cpp | mxl1n/CodeGen | e5101dd5c5e9c3720c70c80f78b18f13e118335a | [
"MIT"
] | 49 | 2021-07-22T23:18:42.000Z | 2022-03-24T09:15:26.000Z | data/transcoder_evaluation_gfg/cpp/COUNT_BINARY_DIGIT_NUMBERS_SMALLER_N.cpp | mxl1n/CodeGen | e5101dd5c5e9c3720c70c80f78b18f13e118335a | [
"MIT"
] | 71 | 2021-07-21T05:17:52.000Z | 2022-03-29T23:49:28.000Z | // Copyright (c) 2019-present, Facebook, Inc.
// All rights reserved.
//
// This source code is licensed under the license found in the
// LICENSE file in the root directory of this source tree.
//
#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <fstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
int f_gold ( int N ) {
queue < int > q;
q . push ( 1 );
int cnt = 0;
int t;
while ( ! q . empty ( ) ) {
t = q . front ( );
q . pop ( );
if ( t <= N ) {
cnt ++;
q . push ( t * 10 );
q . push ( t * 10 + 1 );
}
}
return cnt;
}
//TOFILL
int main() {
int n_success = 0;
vector<int> param0 {1,3,150932532,71,44,36,88,69,53,20};
for(int i = 0; i < param0.size(); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
}
cout << "#Results:" << " " << n_success << ", " << param0.size();
return 0;
} | 20.375 | 69 | 0.527607 | mxl1n |
791bcff4aab5d6974cf4327411cd4c422c555f06 | 48,594 | cpp | C++ | src/serverbase/datatable/DataTableLoader.cpp | mark-online/server | ca24898e2e5a9ccbaa11ef1ade57bb25260b717f | [
"MIT"
] | null | null | null | src/serverbase/datatable/DataTableLoader.cpp | mark-online/server | ca24898e2e5a9ccbaa11ef1ade57bb25260b717f | [
"MIT"
] | null | null | null | src/serverbase/datatable/DataTableLoader.cpp | mark-online/server | ca24898e2e5a9ccbaa11ef1ade57bb25260b717f | [
"MIT"
] | null | null | null | #include "ServerBasePCH.h"
#include <gideon/serverbase/datatable/DataTableLoader.h>
#include <gideon/cs/datatable/DataTableFactory.h>
#include <gideon/cs/datatable/EquipTable.h>
#include <gideon/cs/datatable/ReprocessTable.h>
#include <gideon/cs/datatable/PlayerActiveSkillTable.h>
#include <gideon/cs/datatable/SOActiveSkillTable.h>
#include <gideon/cs/datatable/ItemActiveSkillTable.h>
#include <gideon/cs/datatable/PlayerPassiveSkillTable.h>
#include <gideon/cs/datatable/NpcActiveSkillTable.h>
#include <gideon/cs/datatable/SkillEffectTable.h>
#include <gideon/cs/datatable/NpcTable.h>
#include <gideon/cs/datatable/RecipeTable.h>
#include <gideon/cs/datatable/ElementTable.h>
#include <gideon/cs/datatable/FragmentTable.h>
#include <gideon/cs/datatable/WorldMapTable.h>
#include <gideon/cs/datatable/RegionTable.h>
#include <gideon/cs/datatable/RegionCoordinates.h>
#include <gideon/cs/datatable/RegionSpawnTable.h>
#include <gideon/cs/datatable/PositionSpawnTable.h>
#include <gideon/cs/datatable/ExpTable.h>
#include <gideon/cs/datatable/SelectRecipeProductionTable.h>
#include <gideon/cs/datatable/TreasureTable.h>
#include <gideon/cs/datatable/NpcSellTable.h>
#include <gideon/cs/datatable/NpcBuyTable.h>
#include <gideon/cs/datatable/AnchorTable.h>
#include <gideon/cs/datatable/EntityPathTable.h>
#include <gideon/cs/datatable/ResourcesProductionTable.h>
#include <gideon/cs/datatable/ArenaTable.h>
#include <gideon/cs/datatable/AccessoryTable.h>
//#include <gideon/cs/datatable/StaticObjectSkillTable.h>
#include <gideon/cs/datatable/ActionTable.h>
#include <gideon/cs/datatable/FunctionTable.h>
#include <gideon/cs/datatable/ItemDropTable.h>
#include <gideon/cs/datatable/WorldDropTable.h>
#include <gideon/cs/datatable/WorldDropSuffixTable.h>
#include <gideon/cs/datatable/PropertyTable.h>
#include <gideon/cs/datatable/GemTable.h>
#include <gideon/cs/datatable/QuestTable.h>
#include <gideon/cs/datatable/QuestItemTable.h>
#include <gideon/cs/datatable/QuestKillMissionTable.h>
#include <gideon/cs/datatable/QuestActivationMissionTable.h>
#include <gideon/cs/datatable/QuestProbeMissionTable.h>
#include <gideon/cs/datatable/QuestTransportMissionTable.h>
#include <gideon/cs/datatable/QuestObtainMissionTable.h>
#include <gideon/cs/datatable/QuestContentsMissionTable.h>
#include <gideon/cs/datatable/RandomDungeonTable.h>
#include <gideon/cs/datatable/HarvestTable.h>
#include <gideon/cs/datatable/BuildingTable.h>
#include <gideon/cs/datatable/FactionTable.h>
#include <gideon/cs/datatable/EventTriggerTable.h>
#include <gideon/cs/datatable/DeviceTable.h>
#include <gideon/cs/datatable/GliderTable.h>
#include <gideon/cs/datatable/VehicleTable.h>
#include <gideon/cs/datatable/HarnessTable.h>
#include <gideon/cs/datatable/NpcFormationTable.h>
#include <gideon/cs/datatable/NpcTalkingTable.h>
#include <gideon/cs/datatable/BuildingGuardTable.h>
#include <gideon/cs/datatable/BuildingGuardSellTable.h>
#include <gideon/cs/datatable/WorldEventTable.h>
#include <gideon/cs/datatable/WorldEventMissionTable.h>
#include <gideon/cs/datatable/WorldEventInvaderSpawnTable.h>
#include <gideon/cs/datatable/WorldEventMissionSpawnTable.h>
#include <gideon/cs/datatable/ItemOptionTable.h>
#include <gideon/cs/datatable/ItemSuffixTable.h>
#include <gideon/cs/datatable/CharacterStatusTable.h>
#include <gideon/cs/datatable/CharacterDefaultItemTable.h>
#include <gideon/cs/datatable/CharacterDefaultSkillTable.h>
#include <gideon/cs/datatable/AchievementTable.h>
#include <gideon/cs/datatable/GuildLevelTable.h>
#include <gideon/cs/datatable/GuildSkillTable.h>
#include <sne/server/common/Property.h>
#include <sne/server/utility/Profiler.h>
#include <sne/base/utility/Logger.h>
#include <fstream>
namespace gideon { namespace serverbase {
namespace {
template <typename Table>
inline std::unique_ptr<Table> loadTable(const std::string& tableUrl,
std::unique_ptr<Table> (*createTable)(std::istream& is))
{
std::unique_ptr<Table> table;
std::string why;
std::ifstream ifs(tableUrl.c_str());
if ((! tableUrl.empty()) && ifs.is_open()) {
table = (*createTable)(ifs);
if (table->isLoaded()) {
return table;
}
else {
why = table->getLastError();
}
}
else {
why = "file not found";
}
table.reset();
SNE_LOG_ERROR("Can't load data-table(%s) - %s",
tableUrl.c_str(), why.c_str());
return table;
}
} // namespace
bool DataTableLoader::loadPropertyTable()
{
sne::server::Profiler profiler("DataTableLoader::loadPropertyTable()");
static std::unique_ptr<datatable::PropertyTable> s_propertyTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.property_table_url");
s_propertyTable = loadTable<datatable::PropertyTable>(tableUrl,
datatable::DataTableFactory::createPropertyTable);
if (! s_propertyTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadPropertyTable() FAILED!");
return false;
}
assert(GIDEON_PROPERTY_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadCharacterStatusTable()
{
sne::server::Profiler profiler("DataTableLoader::loadCharacterStatusTable()");
static std::unique_ptr<datatable::CharacterStatusTable> s_characterStatusTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.character_status_table_url");
s_characterStatusTable = loadTable<datatable::CharacterStatusTable>(tableUrl,
datatable::DataTableFactory::createCharacterStatusTable);
if (! s_characterStatusTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadCharacterStatusTable() FAILED!");
return false;
}
assert(CHARACTER_STATUS_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldMapTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldMapTable()");
static std::unique_ptr<datatable::WorldMapTable> s_worldMapTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_map_table_url");
s_worldMapTable = loadTable<datatable::WorldMapTable>(tableUrl,
datatable::DataTableFactory::createWorldMapTable);
if (! s_worldMapTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldMapTable() FAILED!");
return false;
}
assert(WORLDMAP_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadEquipTable()
{
sne::server::Profiler profiler("DataTableLoader::loadEquipTable()");
static std::unique_ptr<datatable::EquipTable> s_equipTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.equip_table_url");
s_equipTable = loadTable<datatable::EquipTable>(tableUrl,
datatable::DataTableFactory::createEquipTable);
if (! s_equipTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadEquipTable() FAILED!");
return false;
}
assert(EQUIP_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadReprocessTable()
{
sne::server::Profiler profiler("DataTableLoader::loadReprocessTable()");
static std::unique_ptr<datatable::ReprocessTable> s_reprocessTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.reprocess_table_url");
s_reprocessTable = loadTable<datatable::ReprocessTable>(tableUrl,
datatable::DataTableFactory::createReprocessTable);
if (! s_reprocessTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadReprocessTable() FAILED!");
return false;
}
assert(REPROCESS_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadPlayerActiveSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadPlayerActiveSkillTable()");
static std::unique_ptr<datatable::PlayerActiveSkillTable> s_playerActiveSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.player_active_skill_table_url");
s_playerActiveSkillTable = loadTable<datatable::PlayerActiveSkillTable>(tableUrl,
datatable::DataTableFactory::createPlayerActiveSkillTableForServer);
if (! s_playerActiveSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadPlayerActiveSkillTable() FAILED!");
return false;
}
assert(PLAYER_ACTIVE_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadItemActiveSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadItemActiveSkillTable()");
static std::unique_ptr<datatable::ItemActiveSkillTable> s_itemActiveSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.item_active_skill_table_url");
s_itemActiveSkillTable = loadTable<datatable::ItemActiveSkillTable>(tableUrl,
datatable::DataTableFactory::createItemActiveSkillTableForServer);
if (! s_itemActiveSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadItemActiveSkillTable() FAILED!");
return false;
}
assert(ITEM_ACTIVE_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadSOActiveSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadSOActiveSkillTable()");
static std::unique_ptr<datatable::SOActiveSkillTable> s_soSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.so_active_skill_table_url");
s_soSkillTable = loadTable<datatable::SOActiveSkillTable>(tableUrl,
datatable::DataTableFactory::createSOActiveSkillTableForServer);
if (! s_soSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadSOActiveSkillTable() FAILED!");
return false;
}
assert(SO_ACTIVE_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadPlayerPassiveSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadPlayerPassiveSkillTable()");
static std::unique_ptr<datatable::PlayerPassiveSkillTable> s_playerPassiveSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.player_passive_skill_table_url");
s_playerPassiveSkillTable = loadTable<datatable::PlayerPassiveSkillTable>(tableUrl,
datatable::DataTableFactory::createPlayerPassiveSkillTableForServer);
if (! s_playerPassiveSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadPlayerPassiveSkillTable() FAILED!");
return false;
}
assert(PLAYER_PASSIVE_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcActiveSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcActiveSkillTable()");
static std::unique_ptr<datatable::NpcActiveSkillTable> s_npcSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_active_skill_table_url");
s_npcSkillTable = loadTable<datatable::NpcActiveSkillTable>(tableUrl,
datatable::DataTableFactory::createNpcActiveSkillTableForServer);
if (! s_npcSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcActiveSkillTable() FAILED!");
return false;
}
assert(NPC_ACTIVE_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadSkillEffectTable()
{
sne::server::Profiler profiler("DataTableLoader::loadSkillEffectTable()");
static std::unique_ptr<datatable::SkillEffectTable> s_skillEffectTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.skill_effect_table_url");
s_skillEffectTable = loadTable<datatable::SkillEffectTable>(tableUrl,
datatable::DataTableFactory::createSkillEffectTable);
if (! s_skillEffectTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadSkillEffectTable() FAILED!");
return false;
}
assert(SKILL_EFFECT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcTable()");
static std::unique_ptr<datatable::NpcTable> s_npcTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_table_url");
s_npcTable = loadTable<datatable::NpcTable>(tableUrl,
datatable::DataTableFactory::createNpcTable);
if (! s_npcTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcTable() FAILED!");
return false;
}
assert(NPC_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadElementTable()
{
sne::server::Profiler profiler("DataTableLoader::loadElementTable()");
static std::unique_ptr<datatable::ElementTable> s_elementTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.element_table_url");
s_elementTable = loadTable<datatable::ElementTable>(tableUrl,
datatable::DataTableFactory::createElementTable);
if (! s_elementTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadElementTable() FAILED!");
return false;
}
assert(ELEMENT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadFragmentTable()
{
sne::server::Profiler profiler("DataTableLoader::loadFragmentTable()");
static std::unique_ptr<datatable::FragmentTable> s_fragmentTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.fragment_table_url");
s_fragmentTable = loadTable<datatable::FragmentTable>(tableUrl,
datatable::DataTableFactory::createFragmentTable);
if (! s_fragmentTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadFragmentTable() FAILED!");
return false;
}
assert(FRAGMENT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadItemDropTable()
{
sne::server::Profiler profiler("DataTableLoader::loadItemDropTable()");
static std::unique_ptr<datatable::ItemDropTable> s_itemDropTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.item_drop_table_url");
s_itemDropTable = loadTable<datatable::ItemDropTable>(tableUrl,
datatable::DataTableFactory::createItemDropTable);
if (! s_itemDropTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadItemDropTable() FAILED!");
return false;
}
assert(ITEM_DROP_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldDropTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldDropTable()");
static std::unique_ptr<datatable::WorldDropTable> s_worldDropTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_drop_table_url");
s_worldDropTable = loadTable<datatable::WorldDropTable>(tableUrl,
datatable::DataTableFactory::createWorldDropTable);
if (! s_worldDropTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldDropTable() FAILED!");
return false;
}
assert(WORLD_DROP_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldDropSuffixTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldDropSuffixTable()");
static std::unique_ptr<datatable::WorldDropSuffixTable> s_worldDropSuffixTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_drop_suffix_table_url");
s_worldDropSuffixTable = loadTable<datatable::WorldDropSuffixTable>(tableUrl,
datatable::DataTableFactory::createWorldDropSuffixTable);
if (! s_worldDropSuffixTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldDropSuffixTable() FAILED!");
return false;
}
assert(WORLD_DROP_SUFFIX_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadGemTable()
{
sne::server::Profiler profiler("DataTableLoader::loadGemTable()");
static std::unique_ptr<datatable::GemTable> s_gemTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.gem_table_url");
s_gemTable = loadTable<datatable::GemTable>(tableUrl,
datatable::DataTableFactory::createGemTable);
if (! s_gemTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadGemTable() FAILED!");
return false;
}
assert(GEM_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadRecipeTable()
{
sne::server::Profiler profiler("DataTableLoader::loadRecipeTable()");
static std::unique_ptr<datatable::RecipeTable> s_recipeTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.recipe_table_url");
s_recipeTable = loadTable<datatable::RecipeTable>(tableUrl,
datatable::DataTableFactory::createRecipeTable);
if (! s_recipeTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadRecipeTable() FAILED!");
return false;
}
assert(RECIPE_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadExpTable()
{
sne::server::Profiler profiler("DataTableLoader::loadExpTable()");
static std::unique_ptr<datatable::ExpTable> s_expTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.exp_table_url");
s_expTable = loadTable<datatable::ExpTable>(tableUrl,
datatable::DataTableFactory::createExpTable);
if (! s_expTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadExpTable() FAILED!");
return false;
}
assert(EXP_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadSelectProductionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadSelectProductionTable()");
static std::unique_ptr<datatable::SelectRecipeProductionTable> s_selectProductionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.select_recipe_production_table_url");
s_selectProductionTable = loadTable<datatable::SelectRecipeProductionTable>(tableUrl,
datatable::DataTableFactory::createSelectRecipeProductionTable);
if (! s_selectProductionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadSelectProductionTable() FAILED!");
return false;
}
assert(SELECT_RECIPE_PRODUCTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadRandomDungeonTable()
{
sne::server::Profiler profiler("DataTableLoader::loadRandomDungeonTable()");
static std::unique_ptr<datatable::RandomDungeonTable> s_randomDungeonTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.random_dungeon_table_url");
s_randomDungeonTable = loadTable<datatable::RandomDungeonTable>(tableUrl,
datatable::DataTableFactory::createRandomDungeonTable);
if (! s_randomDungeonTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadRandomDungeonTable() FAILED!");
return false;
}
assert(RANDOM_DUNGEON_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestTable()");
static std::unique_ptr<datatable::QuestTable> s_questTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_table_url");
s_questTable = loadTable<datatable::QuestTable>(tableUrl,
datatable::DataTableFactory::createQuestTable);
if (! s_questTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestTable() FAILED!");
return false;
}
assert(QUEST_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestItemTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestItemTable()");
static std::unique_ptr<datatable::QuestItemTable> s_questItemTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_item_table_url");
s_questItemTable = loadTable<datatable::QuestItemTable>(tableUrl,
datatable::DataTableFactory::createQuestItemTable);
if (! s_questItemTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestItemTable() FAILED!");
return false;
}
assert(QUEST_ITEM_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestKillMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestKillMissionTable()");
static std::unique_ptr<datatable::QuestKillMissionTable> s_questKillMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_kill_mission_table_url");
s_questKillMissionTable = loadTable<datatable::QuestKillMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestKillMissionTable);
if (! s_questKillMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestKillMissionTable() FAILED!");
return false;
}
assert(QUEST_KILL_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestActivationMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestActivationMissionTable()");
static std::unique_ptr<datatable::QuestActivationMissionTable> s_questActivationMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_activation_mission_table_url");
s_questActivationMissionTable = loadTable<datatable::QuestActivationMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestActivationMissionTable);
if (! s_questActivationMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestActivationMissionTable() FAILED!");
return false;
}
assert(QUEST_ACTIVATION_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestObtainMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestObtainMissionTable()");
static std::unique_ptr<datatable::QuestObtainMissionTable> s_questObtainMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_obtain_mission_table_url");
s_questObtainMissionTable = loadTable<datatable::QuestObtainMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestObtainMissionTable);
if (! s_questObtainMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestObtainMissionTable() FAILED!");
return false;
}
assert(QUEST_OBTAIN_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestProbeMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestProbeMissionTable()");
static std::unique_ptr<datatable::QuestProbeMissionTable> s_questProbeMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_probe_mission_table_url");
s_questProbeMissionTable = loadTable<datatable::QuestProbeMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestProbeMissionTable);
if (! s_questProbeMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestProbeMissionTable() FAILED!");
return false;
}
assert(QUEST_PROBE_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestTransportMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestTransportMissionTable()");
static std::unique_ptr<datatable::QuestTransportMissionTable> s_questTransportMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_transport_mission_table_url");
s_questTransportMissionTable = loadTable<datatable::QuestTransportMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestTransportMissionTable);
if (! s_questTransportMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestTransportMissionTable() FAILED!");
return false;
}
assert(QUEST_TRANSPORT_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadQuestContentsMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadQuestContentsMissionTable()");
static std::unique_ptr<datatable::QuestContentsMissionTable> s_questContentstMissionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.quest_contents_mission_table_url");
s_questContentstMissionTable = loadTable<datatable::QuestContentsMissionTable>(tableUrl,
datatable::DataTableFactory::createQuestContentsMissionTable);
if (! s_questContentstMissionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadQuestContentsMissionTable() FAILED!");
return false;
}
assert(QUEST_CONTENTS_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadHarvestTable()
{
sne::server::Profiler profiler("DataTableLoader::loadHarvestTable()");
static std::unique_ptr<datatable::HarvestTable> s_harvestTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.harvest_table_url");
s_harvestTable = loadTable<datatable::HarvestTable>(tableUrl,
datatable::DataTableFactory::createHarvestTable);
if (! s_harvestTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadHarvestTable() FAILED!");
return false;
}
assert(HARVEST_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadTreasureTable()
{
sne::server::Profiler profiler("DataTableLoader::loadTreasureTable()");
static std::unique_ptr<datatable::TreasureTable> s_treasureTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.treasure_table_url");
s_treasureTable = loadTable<datatable::TreasureTable>(tableUrl,
datatable::DataTableFactory::createTreasureTable);
if (! s_treasureTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadTreasureTable() FAILED!");
return false;
}
assert(TREASURE_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcSellTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcSellTable()");
static std::unique_ptr<datatable::NpcSellTable> s_npcSellTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_sell_table_url");
s_npcSellTable = loadTable<datatable::NpcSellTable>(tableUrl,
datatable::DataTableFactory::createNpcSellTable);
if (! s_npcSellTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcSellTable() FAILED!");
return false;
}
assert(NPC_SELL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcBuyTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcBuyTable()");
static std::unique_ptr<datatable::NpcBuyTable> s_npcBuyTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_buy_table_url");
s_npcBuyTable = loadTable<datatable::NpcBuyTable>(tableUrl,
datatable::DataTableFactory::createNpcBuyTable);
if (! s_npcBuyTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcBuyTable() FAILED!");
return false;
}
assert(NPC_BUY_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadAnchorTable()
{
sne::server::Profiler profiler("DataTableLoader::loadAnchorTable()");
static std::unique_ptr<datatable::AnchorTable> s_anchorTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.anchor_table_url");
s_anchorTable = loadTable<datatable::AnchorTable>(tableUrl,
datatable::DataTableFactory::createAnchorTable);
if (! s_anchorTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadAnchorTable() FAILED!");
return false;
}
assert(ANCHOR_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadArenaTable()
{
sne::server::Profiler profiler("DataTableLoader::loadArenaTable()");
static std::unique_ptr<datatable::ArenaTable> s_arenaTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.arena_table_url");
s_arenaTable = loadTable<datatable::ArenaTable>(tableUrl,
datatable::DataTableFactory::createArenaTable);
if (! s_arenaTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadArenaTable() FAILED!");
return false;
}
assert(ARENA_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadAccessoryTable()
{
sne::server::Profiler profiler("DataTableLoader::loadAccessoryTable()");
static std::unique_ptr<datatable::AccessoryTable> s_accessoryTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.accessory_table_url");
s_accessoryTable = loadTable<datatable::AccessoryTable>(tableUrl,
datatable::DataTableFactory::createAccessoryTable);
if (! s_accessoryTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadAccessoryTable() FAILED!");
SNE_LOG_ERROR("DataTableLoader::loadAccessoryTable() FAILED!");
return false;
}
assert(ACCESSORY_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadBuildingTable()
{
sne::server::Profiler profiler("DataTableLoader::loadBuildingTable()");
static std::unique_ptr<datatable::BuildingTable> s_buildingTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.building_table_url");
s_buildingTable = loadTable<datatable::BuildingTable>(tableUrl,
datatable::DataTableFactory::createBuildingTable);
if (! s_buildingTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadBuildingTable() FAILED!");
return false;
}
assert(BUILDING_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadResourcesProductionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadResourcesProductionTable()");
static std::unique_ptr<datatable::ResourcesProductionTable> s_resourcesProductionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.resources_production_table_url");
s_resourcesProductionTable = loadTable<datatable::ResourcesProductionTable>(tableUrl,
datatable::DataTableFactory::createResourcesProductionTable);
if (! s_resourcesProductionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadResourcesProductionTable() FAILED!");
return false;
}
assert(RESOURCES_PRODUCTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadFactionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadFactionTable()");
static std::unique_ptr<datatable::FactionTable> s_factionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.faction_table_url");
s_factionTable = loadTable<datatable::FactionTable>(tableUrl,
datatable::DataTableFactory::createFactionTable);
if (! s_factionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadFactionTable() FAILED!");
return false;
}
assert(FACTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadEventTriggerTable()
{
sne::server::Profiler profiler("DataTableLoader::loadEventTriggerTable()");
static std::unique_ptr<datatable::EventTriggerTable> s_eventAiTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.event_trigger_table_url");
s_eventAiTable = loadTable<datatable::EventTriggerTable>(tableUrl,
datatable::DataTableFactory::createEventTriggerTable);
if (! s_eventAiTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadEventTriggerTable() FAILED!");
return false;
}
assert(EVT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadDeviceTable()
{
sne::server::Profiler profiler("DataTableLoader::loadDeviceTable()");
static std::unique_ptr<datatable::DeviceTable> s_deviceTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.device_table_url");
s_deviceTable = loadTable<datatable::DeviceTable>(tableUrl,
datatable::DataTableFactory::createDeviceTable);
if (! s_deviceTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadDeviceTable() FAILED!");
return false;
}
assert(DEVICE_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadGliderTable()
{
sne::server::Profiler profiler("DataTableLoader::loadGliderTable()");
static std::unique_ptr<datatable::GliderTable> s_gliderTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.glider_table_url");
s_gliderTable = loadTable<datatable::GliderTable>(tableUrl,
datatable::DataTableFactory::createGliderTable);
if (! s_gliderTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadGliderTable() FAILED!");
return false;
}
assert(GLIDER_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadFunctionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadFunctionTable()");
static std::unique_ptr<datatable::FunctionTable> s_functionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.function_table_url");
s_functionTable = loadTable<datatable::FunctionTable>(tableUrl,
datatable::DataTableFactory::createFunctionTable);
if (! s_functionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadFunctionTable() FAILED!");
return false;
}
assert(FUNCTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadVehicleTable()
{
sne::server::Profiler profiler("DataTableLoader::loadVehicleTable()");
static std::unique_ptr<datatable::VehicleTable> s_vehicleTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.vehicle_table_url");
s_vehicleTable = loadTable<datatable::VehicleTable>(tableUrl,
datatable::DataTableFactory::createVehicleTable);
if (! s_vehicleTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadVehicleTable() FAILED!");
return false;
}
assert(VEHICLE_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadHarnessTable()
{
sne::server::Profiler profiler("DataTableLoader::loadHarnessTable()");
static std::unique_ptr<datatable::HarnessTable> s_harnessTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.harness_table_url");
s_harnessTable = loadTable<datatable::HarnessTable>(tableUrl,
datatable::DataTableFactory::createHarnessTable);
if (! s_harnessTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadHarnessTable() FAILED!");
return false;
}
assert(HARNESS_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadActionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadActionTable()");
static std::unique_ptr<datatable::ActionTable> s_actionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.action_table_url");
s_actionTable = loadTable<datatable::ActionTable>(tableUrl,
datatable::DataTableFactory::createActionTable);
if (! s_actionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadActionTable() FAILED!");
return false;
}
assert(ACTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcFormationTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcFormationTable()");
static std::unique_ptr<datatable::NpcFormationTable> s_npcFormationTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_formation_table_url");
s_npcFormationTable = loadTable<datatable::NpcFormationTable>(tableUrl,
datatable::DataTableFactory::createNpcFormationTable);
if (! s_npcFormationTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcFormationTable() FAILED!");
return false;
}
assert(NPC_FORMATION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadNpcTalkingTable()
{
sne::server::Profiler profiler("DataTableLoader::loadNpcTalkingTable()");
static std::unique_ptr<datatable::NpcTalkingTable> s_npcTalkingTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.npc_talking_table_url");
s_npcTalkingTable = loadTable<datatable::NpcTalkingTable>(tableUrl,
datatable::DataTableFactory::createNpcTalkingTable);
if (! s_npcTalkingTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadNpcTalkingTable() FAILED!");
return false;
}
assert(NPC_TALKING_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadBuildingGuardTable()
{
sne::server::Profiler profiler("DataTableLoader::loadBuildingGuardTable()");
static std::unique_ptr<datatable::BuildingGuardTable> s_buildingGuard;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.building_guard_table_url");
s_buildingGuard = loadTable<datatable::BuildingGuardTable>(tableUrl,
datatable::DataTableFactory::createBuildingGuardTable);
if (! s_buildingGuard.get()) {
SNE_LOG_ERROR("DataTableLoader::loadBuildingGuardTable() FAILED!");
return false;
}
assert(BUILDING_GUARD_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadBuildingGuardSellTable()
{
sne::server::Profiler profiler("DataTableLoader::loadBuildingGuardSellTable()");
static std::unique_ptr<datatable::BuildingGuardSellTable> s_buildingGuardSell;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.building_guard_sell_table_url");
s_buildingGuardSell = loadTable<datatable::BuildingGuardSellTable>(tableUrl,
datatable::DataTableFactory::createBuildingGuardSellTable);
if (! s_buildingGuardSell.get()) {
SNE_LOG_ERROR("DataTableLoader::loadBuildingGuardSellTable() FAILED!");
return false;
}
assert(BUILDING_GUARD_SELL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldEventTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldEventTable()");
static std::unique_ptr<datatable::WorldEventTable> s_worldEvent;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_event_table_url");
s_worldEvent = loadTable<datatable::WorldEventTable>(tableUrl,
datatable::DataTableFactory::createWorldEventTable);
if (! s_worldEvent.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldEventTable() FAILED!");
return false;
}
assert(WORLD_EVENT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldEventMissionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldEventMissionTable()");
static std::unique_ptr<datatable::WorldEventMissionTable> s_worldEventMission;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_event_mission_table_url");
s_worldEventMission = loadTable<datatable::WorldEventMissionTable>(tableUrl,
datatable::DataTableFactory::createWorldEventMissionTable);
if (! s_worldEventMission.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldEventMissionTable() FAILED!");
return false;
}
assert(WORLD_EVENT_MISSION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldEventInvaderSpawnTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldEventInvaderSpawnTable()");
static std::unique_ptr<datatable::WorldEventInvaderSpawnTable> s_worldEventInvaderSpawn;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_event_invader_spawn_table_url");
s_worldEventInvaderSpawn = loadTable<datatable::WorldEventInvaderSpawnTable>(tableUrl,
datatable::DataTableFactory::createWorldEventInvaderSpawnTable);
if (! s_worldEventInvaderSpawn.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldEventInvaderSpawnTable() FAILED!");
return false;
}
assert(WORLD_EVENT_INVADER_SPAWN_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadWorldEventMissionSpawnTable()
{
sne::server::Profiler profiler("DataTableLoader::loadWorldEventMissionSpawnTable()");
static std::unique_ptr<datatable::WorldEventMissionSpawnTable> s_worldEventMissionSpawn;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.world_event_mission_spawn_table_url");
s_worldEventMissionSpawn = loadTable<datatable::WorldEventMissionSpawnTable>(tableUrl,
datatable::DataTableFactory::createWorldEventMissionSpawnTable);
if (! s_worldEventMissionSpawn.get()) {
SNE_LOG_ERROR("DataTableLoader::loadWorldEventMissionSpawnTable() FAILED!");
return false;
}
assert(WORLD_EVENT_MISSION_SPAWN_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadItemOptionTable()
{
sne::server::Profiler profiler("DataTableLoader::loadItemOptionTable()");
static std::unique_ptr<datatable::ItemOptionTable> s_itemOptionTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.item_option_table_url");
s_itemOptionTable = loadTable<datatable::ItemOptionTable>(tableUrl,
datatable::DataTableFactory::creatItemOptionTable);
if (! s_itemOptionTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadItemOptionTable() FAILED!");
return false;
}
assert(ITEM_OPTION_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadItemSuffixTable()
{
sne::server::Profiler profiler("DataTableLoader::loadItemSuffixTable()");
static std::unique_ptr<datatable::ItemSuffixTable> s_itemSuffixTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.item_suffix_table_url");
s_itemSuffixTable = loadTable<datatable::ItemSuffixTable>(tableUrl,
datatable::DataTableFactory::createItemSuffixTable);
if (! s_itemSuffixTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadItemSuffixTable() FAILED!");
return false;
}
assert(ITEM_SUFFIX_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadCharacterDefaultItemTable()
{
sne::server::Profiler profiler("DataTableLoader::loadCharacterDefaultItemTable()");
static std::unique_ptr<datatable::CharacterDefaultItemTable> s_characterDefaultItemTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.character_default_item_table_url");
s_characterDefaultItemTable = loadTable<datatable::CharacterDefaultItemTable>(tableUrl,
datatable::DataTableFactory::createCharacterDefaultItemTable);
if (! s_characterDefaultItemTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadCharacterDefaultItemTable() FAILED!");
return false;
}
assert(CHARACTER_DEFAULT_ITEM_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadCharacterDefaultSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadCharacterDefaultSkillTable()");
static std::unique_ptr<datatable::CharacterDefaultSkillTable> s_characterDefaultSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.character_default_skill_table_url");
s_characterDefaultSkillTable = loadTable<datatable::CharacterDefaultSkillTable>(tableUrl,
datatable::DataTableFactory::createCharacterDefaultSkillTable);
if (! s_characterDefaultSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadCharacterDefaultSkillTable() FAILED!");
return false;
}
assert(CHARACTER_DEFAULT_SKILL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadAchievementTable()
{
sne::server::Profiler profiler("DataTableLoader::loadAchievementTable()");
static std::unique_ptr<datatable::AchievementTable> s_achievementTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.achievement_table_url");
s_achievementTable = loadTable<datatable::AchievementTable>(tableUrl,
datatable::DataTableFactory::createAchievementTable);
if (! s_achievementTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadAchievementTable() FAILED!");
return false;
}
assert(ACHIEVEMENT_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadGuildLevelTable()
{
sne::server::Profiler profiler("DataTableLoader::loadGuildLevelTable()");
static std::unique_ptr<datatable::GuildLevelTable> s_guildLevel;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.guild_level_table_url");
s_guildLevel = loadTable<datatable::GuildLevelTable>(tableUrl,
datatable::DataTableFactory::createGuildLevelTable);
if (! s_guildLevel.get()) {
SNE_LOG_ERROR("DataTableLoader::loadGuildLevelTable() FAILED!");
return false;
}
assert(GUILD_LEVEL_TABLE != nullptr);
return true;
}
bool DataTableLoader::loadGuildSkillTable()
{
sne::server::Profiler profiler("DataTableLoader::loadGuildSkillTable()");
static std::unique_ptr<datatable::GuildSkillTable> s_guildSkillTable;
const std::string tableUrl =
SNE_PROPERTIES::getProperty<std::string>("data_table.guild_skill_table_url");
s_guildSkillTable = loadTable<datatable::GuildSkillTable>(tableUrl,
datatable::DataTableFactory::createGuildSkillTable);
if (! s_guildSkillTable.get()) {
SNE_LOG_ERROR("DataTableLoader::loadGuildSkillTable() FAILED!");
return false;
}
assert(GUILD_SKILL_TABLE != nullptr);
return true;
}
std::unique_ptr<datatable::RegionTable>
DataTableLoader::loadRegionTable(MapCode mapCode)
{
if (! isValidMapCode(mapCode)) {
return std::unique_ptr<datatable::RegionTable>();
}
std::string urlPrefix;
if (getMapType(mapCode) == mtArena) {
urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.arena_region_table_url_prefix");
}
else {
urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.region_table_url_prefix");
}
const std::string regionUrl = urlPrefix +
boost::lexical_cast<std::string>(mapCode) + ".xml";
return loadTable<datatable::RegionTable>(regionUrl,
datatable::DataTableFactory::createRegionTable);
}
std::unique_ptr<datatable::RegionCoordinates>
DataTableLoader::loadRegionCoordinates(MapCode mapCode)
{
const std::string urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.region_coordinates_url_prefix");
const std::string coordinatesUrl = urlPrefix +
boost::lexical_cast<std::string>(mapCode) + ".xml";
return loadTable<datatable::RegionCoordinates>(coordinatesUrl,
datatable::DataTableFactory::createRegionCoordinates);
}
std::unique_ptr<datatable::RegionSpawnTable>
DataTableLoader::loadRegionSpawnTable(MapCode mapCode)
{
const std::string urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.region_spawn_table_url_prefix");
const std::string regionUrl = urlPrefix +
boost::lexical_cast<std::string>(mapCode) + ".xml";
return loadTable<datatable::RegionSpawnTable>(regionUrl,
datatable::DataTableFactory::createRegionSpawnTable);
}
std::unique_ptr<datatable::PositionSpawnTable>
DataTableLoader::loadPositionSpawnTable(MapCode mapCode)
{
const std::string urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.position_spawn_table_url_prefix");
const std::string regionUrl = urlPrefix +
boost::lexical_cast<std::string>(mapCode) + ".xml";
return loadTable<datatable::PositionSpawnTable>(regionUrl,
datatable::DataTableFactory::createPositionSpawnTable);
}
std::unique_ptr<datatable::EntityPathTable>
DataTableLoader::loadEntityPathTable(MapCode mapCode)
{
const std::string urlPrefix =
SNE_PROPERTIES::getProperty<std::string>("data_table.entity_path_table_url_prefix");
const std::string regionUrl = urlPrefix +
boost::lexical_cast<std::string>(mapCode) + ".xml";
return loadTable<datatable::EntityPathTable>(regionUrl,
datatable::DataTableFactory::createEntityPathTable);
}
}} // namespace gideon { namespace serverbase {
| 33.629066 | 99 | 0.733239 | mark-online |
791bd9f25de87d534cc12baf44afa66676321528 | 5,546 | cpp | C++ | tests/src/general.cpp | kstenerud/c-cbe | e842ae485088cb962f549bcf0a9024d795797d26 | [
"MIT"
] | null | null | null | tests/src/general.cpp | kstenerud/c-cbe | e842ae485088cb962f549bcf0a9024d795797d26 | [
"MIT"
] | null | null | null | tests/src/general.cpp | kstenerud/c-cbe | e842ae485088cb962f549bcf0a9024d795797d26 | [
"MIT"
] | 1 | 2019-10-02T23:07:40.000Z | 2019-10-02T23:07:40.000Z | #include "helpers/test_helpers.h"
// #define KSLog_LocalMinLevel KSLOG_LEVEL_TRACE
#include <kslog/kslog.h>
using namespace encoding;
TEST_ENCODE_DECODE_SHRINKING(Bool, false, 0, b(false), {0x7c})
TEST_ENCODE_DECODE_SHRINKING(Bool, true, 0, b(true), {0x7d})
TEST_ENCODE_DECODE_SHRINKING(Int, p0, 0, i( 1, 0), {0x00})
TEST_ENCODE_DECODE_SHRINKING(Int, p1, 0, i( 1, 1), {0x01})
TEST_ENCODE_DECODE_SHRINKING(Int, p100, 0, i( 1, 100), {0x64})
TEST_ENCODE_DECODE_SHRINKING(Int, n1, 0, i(-1, 1), {0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, n100, 0, i(-1, 100), {0x9c})
TEST_ENCODE_DECODE_SHRINKING(Int, p101, 0, i( 1, 101), {0x68, 0x65})
TEST_ENCODE_DECODE_SHRINKING(Int, n101, 0, i(-1, 101), {0x69, 0x65})
TEST_ENCODE_DECODE_SHRINKING(Int, px7f, 0, i( 1, 0x7f), {0x68, 0x7f})
TEST_ENCODE_DECODE_SHRINKING(Int, nx80, 0, i(-1, 0x80), {0x69, 0x80})
TEST_ENCODE_DECODE_SHRINKING(Int, pxff, 0, i( 1, 0xff), {0x68, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, nxff, 0, i(-1, 0xff), {0x69, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, px100, 0, i( 1, 0x100), {0x6a, 0x00, 0x01})
TEST_ENCODE_DECODE_SHRINKING(Int, nx100, 0, i(-1, 0x100), {0x6b, 0x00, 0x01})
TEST_ENCODE_DECODE_SHRINKING(Int, p7fff, 0, i( 1, 0x7fff), {0x6a, 0xff, 0x7f})
TEST_ENCODE_DECODE_SHRINKING(Int, n8000, 0, i(-1, 0x8000), {0x6b, 0x00, 0x80})
TEST_ENCODE_DECODE_SHRINKING(Int, pffff, 0, i( 1, 0xffff), {0x6a, 0xff, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, nffff, 0, i(-1, 0xffff), {0x6b, 0xff, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, p10000, 0, i( 1, 0x10000), {0x66, 0x84, 0x80, 0x00})
TEST_ENCODE_DECODE_SHRINKING(Int, n10000, 0, i(-1, 0x10000), {0x67, 0x84, 0x80, 0x00})
TEST_ENCODE_DECODE_SHRINKING(Int, p7fffffff, 0, i( 1, 0x7fffffff), {0x6c, 0xff, 0xff, 0xff, 0x7f})
TEST_ENCODE_DECODE_SHRINKING(Int, n80000000, 0, i(-1, 0x80000000L), {0x6d, 0x00, 0x00, 0x00, 0x80})
TEST_ENCODE_DECODE_SHRINKING(Int, pffffffff, 0, i( 1, 0xffffffff), {0x6c, 0xff, 0xff, 0xff, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, nffffffff, 0, i(-1, 0xffffffffL), {0x6d, 0xff, 0xff, 0xff, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Int, p100000000, 0, i( 1, 0x100000000L), {0x66, 0x90, 0x80, 0x80, 0x80, 0x00})
TEST_ENCODE_DECODE_SHRINKING(Int, n100000000, 0, i(-1, 0x100000000L), {0x67, 0x90, 0x80, 0x80, 0x80, 0x00})
TEST_ENCODE_DECODE_SHRINKING(Int, p7fffffffffffffff, 0, i( 1, 0x7fffffffffffffffL), {0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f})
TEST_ENCODE_DECODE_SHRINKING(Int, n8000000000000000, 0, i(-1, 0x8000000000000000L), {0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80})
TEST_ENCODE_DECODE_SHRINKING(Int, pffffffffffffffff, 0, i( 1, 0xffffffffffffffffL), {0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff})
TEST_ENCODE_DECODE_SHRINKING(Float, p0_0, 0, f(0.0, 0), {0x70, 0x00, 0x00, 0x00, 0x00})
TEST_ENCODE_DECODE_SHRINKING(Float, n967234_125, 0, f(-967234.125, 0), {0x70, 0x22, 0x24, 0x6c, 0xc9})
TEST_ENCODE_DECODE_SHRINKING(Float, p1_0123, 0, f(1.0123, 0), {0x71, 0x51, 0xda, 0x1b, 0x7c, 0x61, 0x32, 0xf0, 0x3f})
TEST_ENCODE_DECODE_SHRINKING(Date, 2015_01_15, 0, d(2015, 1, 15), {0x99, 0x2f, 0x00, 0x1e})
TEST_ENCODE_DECODE_SHRINKING(Time, 23_14_43_1, 0, t(23, 14, 43, 1000000000), {0x9a, 0xbb, 0xce, 0x8a, 0x3e})
TEST_ENCODE_DECODE_SHRINKING(Time, 23_14_43_1_Berlin, 0, t(23, 14, 43, 1000000000, "E/Berlin"), {0x9a, 0xba, 0xce, 0x8a, 0x3e, 0x10, 'E', '/', 'B', 'e', 'r', 'l', 'i', 'n'})
TEST_ENCODE_DECODE_SHRINKING(Time, 23_14_43_1_loc, 0, t(23, 14, 43, 1000000000, 1402, 2099), {0x9a, 0xba, 0xce, 0x8a, 0x3e, 0xf5, 0x8a, 0x19, 0x04})
TEST_ENCODE_DECODE_SHRINKING(Timestamp, 1955_11_11_22_38_0_1, 0, ts(1955, 11, 11, 22, 38, 0, 1), {0x9b, 0x03, 0xa6, 0x5d, 0x1b, 0x00, 0x00, 0x00, 0x04, 0x33})
TEST_ENCODE_DECODE_SHRINKING(Timestamp, 1985_10_26_01_22_16_LA, 0, ts(1985, 10, 26, 1, 22, 16, 0, "M/Los_Angeles"), {0x9b, 0x40, 0x56, 0xd0, 0x0a, 0x3a, 0x1a, 'M', '/', 'L', 'o', 's', '_', 'A', 'n', 'g', 'e', 'l', 'e', 's'})
TEST_ENCODE_DECODE_SHRINKING(Timestamp, 2015_10_21_07_28_00_loc, 0, ts(2015, 10, 21, 7, 28, 0, 0, 3399, 11793), {0x9b, 0x00, 0xdc, 0xa9, 0x0a, 0x3c, 0x8f, 0x9a, 0x08, 0x17})
TEST_ENCODE_DECODE_DATA_ENCODING(DecFloat, 0_1, 99, 9, df(0.1dd, 0), df(0.1, 0), {0x65, 0x06, 0x01})
TEST_ENCODE_DECODE_DATA_ENCODING(DecFloat, 0_194_2, 99, 9, df(0.194dd, 2), df(0.19, 0), {0x65, 0x0a, 0x13})
TEST_ENCODE_DECODE_DATA_ENCODING(DecFloat, 19_4659234442e100_9, 99, 9, df(19.4659234442e100, 9), df(1.94659234e101, 0), {0x65, 0x82, 0x74, 0xdc, 0xe9, 0x87, 0x22})
TEST_ENCODE_DECODE_SHRINKING(Nil, nil, 0, nil(), {0x7e})
TEST_ENCODE_DATA(Padding, pad_1, 99, 9, pad(1), {0x7f})
TEST_ENCODE_DATA(Padding, pad_2, 99, 9, pad(2), {0x7f, 0x7f})
TEST_STOP_IN_CALLBACK(SIC, Nil, nil())
TEST_STOP_IN_CALLBACK(SIC, Bool, b(false))
TEST_STOP_IN_CALLBACK(SIC, Int, i(1))
TEST_STOP_IN_CALLBACK(SIC, Float, f(1, 0))
TEST_STOP_IN_CALLBACK(SIC, Decimal, df(1, 1))
TEST_STOP_IN_CALLBACK(SIC, Date, d(1, 1, 1))
TEST_STOP_IN_CALLBACK(SIC, Time, t(1, 1, 1, 1))
TEST_STOP_IN_CALLBACK(SIC, Time_zone, t(1, 1, 1, 1, "E/Berlin"))
TEST_STOP_IN_CALLBACK(SIC, Time_loc, t(1, 1, 1, 1, 0, 0))
TEST_STOP_IN_CALLBACK(SIC, Timestamp, ts(1, 1, 1, 1, 1, 1, 1))
TEST_STOP_IN_CALLBACK(SIC, Timestamp_zone, ts(1, 1, 1, 1, 1, 1, 1, "E/Berlin"))
TEST_STOP_IN_CALLBACK(SIC, Timestamp_loc, ts(1, 1, 1, 1, 1, 1, 1, 0, 0))
TEST_STOP_IN_CALLBACK(SIC, List, list().end())
TEST_STOP_IN_CALLBACK(SIC, Map, umap().end())
TEST_STOP_IN_CALLBACK(SIC, String, str("test"))
TEST_STOP_IN_CALLBACK(SIC, Bytes, bin(std::vector<uint8_t>()))
| 69.325 | 224 | 0.703931 | kstenerud |
791c9ab9c4e0c2969625dec69ac7b20ee96f383c | 3,535 | cpp | C++ | Metazion/Net/ComConnecter.cpp | KaleoFeng/Metazion | 5f1149d60aa87b391c2f40de7a89a5044701f2ca | [
"MIT"
] | 15 | 2018-10-30T07:49:02.000Z | 2020-10-20T06:27:08.000Z | Metazion/Net/ComConnecter.cpp | kaleofeng/metazion | 5f1149d60aa87b391c2f40de7a89a5044701f2ca | [
"MIT"
] | null | null | null | Metazion/Net/ComConnecter.cpp | kaleofeng/metazion | 5f1149d60aa87b391c2f40de7a89a5044701f2ca | [
"MIT"
] | 5 | 2020-12-04T07:39:31.000Z | 2021-11-23T03:16:39.000Z | #include "Metazion/Net/ComConnecter.hpp"
#include <Metazion/Share/Time/Time.hpp>
#include "Metazion/Net/TransmitSocket.hpp"
DECL_NAMESPACE_MZ_NET_BEGIN
ComConnecter::ComConnecter(TransmitSocket& socket)
: m_socket(socket) {}
ComConnecter::~ComConnecter() {}
void ComConnecter::Reset() {
m_stage = STAGE_NONE;
m_connectTime = 0;
m_reconnectInterval = 0;
m_tempSockId = INVALID_SOCKID;
}
void ComConnecter::Tick(int64_t now, int interval) {
ConnectStage();
}
bool ComConnecter::Connect() {
SetStage(STAGE_WAITING);
return true;
}
void ComConnecter::ConnectStage() {
switch (m_stage) {
case STAGE_WAITING:
ConnectStageWaiting();
break;
case STAGE_CONNECTING:
ConnectStageConnecting();
break;
case STAGE_CONNECTED:
ConnectStageConnected();
break;
case STAGE_CLOSED:
ConnectStageClosed();
break;
default: MZ_ASSERT_TRUE(false); break;
}
}
void ComConnecter::ConnectStageWaiting() {
const auto now = NS_SHARE::GetNowMillisecond();
if (now < m_connectTime) {
return;
}
const auto ret = TryToConnect();
if (ret == 0) {
SetStage(STAGE_CONNECTING);
}
else if (ret > 0) {
m_socket.AttachSockId(m_tempSockId);
SetStage(STAGE_CONNECTED);
}
else {
m_connectFaildCallback();
Reconnect(m_reconnectInterval);
}
}
void ComConnecter::ConnectStageConnecting() {
const auto ret = CheckConnected();
if (ret == 0) {
// Keep connecting.
}
else if (ret > 0) {
m_socket.AttachSockId(m_tempSockId);
SetStage(STAGE_CONNECTED);
}
else {
DetachTempSockId();
m_connectFaildCallback();
Reconnect(m_reconnectInterval);
}
}
void ComConnecter::ConnectStageConnected() {
if (m_socket.IsActive()) {
return;
}
if (m_socket.IsWannaClose()) {
return;
}
Reconnect(1000);
}
void ComConnecter::ConnectStageClosed() {
MZ_ASSERT_TRUE(!m_socket.IsActive());
}
void ComConnecter::Reconnect(int milliseconds) {
if (m_reconnectInterval < 0) {
SetStage(STAGE_CLOSED);
return;
}
ResetConnectTime(milliseconds);
SetStage(STAGE_WAITING);
}
int ComConnecter::TryToConnect() {
auto sockId = CreateSockId(TRANSPORT_TCP);
if (sockId == INVALID_SOCKID) {
return -1;
}
AttachTempSockId(sockId);
auto sockAddr = m_socket.GetRemoteHost().SockAddr();
auto sockAddrLen = m_socket.GetRemoteHost().SockAddrLen();
const auto ret = connect(m_tempSockId, sockAddr, sockAddrLen);
if (ret < 0) {
const auto error = SAGetLastError();
if (!IsConnectWouldBlock(error)) {
DetachTempSockId();
return -1;
}
return 0;
}
return 1;
}
int ComConnecter::CheckConnected() {
const auto ret = CheckSockConnected(m_tempSockId);
if (ret <= 0) {
return ret;
}
// It doesn't work in some situations on linux platform.
// For examle, when listen socket's backlog queue is full.
// And also doesn't work on solaris platform.
int optValue = 0;
auto optLength = static_cast<SockLen_t>(sizeof(optValue));
GetSockOpt(m_tempSockId, SOL_SOCKET, SO_ERROR, &optValue, &optLength);
if (optValue != 0) {
return -1;
}
return 1;
}
void ComConnecter::ResetConnectTime(int milliseconds) {
m_connectTime = NS_SHARE::GetNowMillisecond() + milliseconds;
}
DECL_NAMESPACE_MZ_NET_END
| 22.373418 | 74 | 0.641018 | KaleoFeng |
791d885f188c80d179c98a85704257f95f428020 | 12,185 | cpp | C++ | Computing-III/HW7/hw7.cpp | DulceWRLD/College | 9b94868514f461c97121d72ea0855f72ca95e798 | [
"MIT"
] | 2 | 2021-08-21T01:25:50.000Z | 2021-12-10T06:51:46.000Z | Computing-III/HW7/hw7.cpp | DulceWRLD/College | 9b94868514f461c97121d72ea0855f72ca95e798 | [
"MIT"
] | null | null | null | Computing-III/HW7/hw7.cpp | DulceWRLD/College | 9b94868514f461c97121d72ea0855f72ca95e798 | [
"MIT"
] | 6 | 2021-03-14T22:21:23.000Z | 2022-03-29T15:30:58.000Z | #include <iostream>
#include <vector>
// Avoid typing std:: everywhere
using std::cout;
using std::cin;
using std::string;
using std::endl;
using std::vector;
class ComputerLabs
{
public:
ComputerLabs();
void show_labs(void);
void login(void);
void logoff(void);
void searchUser(void);
void addLab(void);
void addComp(void);
void removeLab(void);
void removeComp(void);
private:
/* 2D vector of strings
Basically:
first [] is a vector (lab) of computers
second [] is a specific computer in that lab */
vector < vector <string> > labs;
};
int main()
{
ComputerLabs computer_lab;
int ans;
do{
cout << "\nPlease enter one of the following options \n";
cout << "1) Display all the labs, computers, and users \n";
cout << "2) Login \n";
cout << "3) Logoff \n";
cout << "4) Search user \n";
cout << "5) Add a computer \n";
cout << "6) Add a lab \n";
cout << "7) Remove a computer \n";
cout << "8) Remove a lab \n";
cout << "9) Quit \n";
cout << "Enter your selection: ";
cin >> ans;
switch(ans)
{
case 1:
computer_lab.show_labs();
break;
case 2:
computer_lab.login();
break;
case 3:
computer_lab.logoff();
break;
case 4:
computer_lab.searchUser();
break;
case 5:
computer_lab.addComp();
break;
case 6:
computer_lab.addLab();
break;
case 7:
computer_lab.removeComp();
break;
case 8:
computer_lab.removeLab();
break;
case 9:
cout << "\nQuitting the program...\n";
break;
default:
cout << "\n*********************************\n";
cout << "Error, you entered invalid input!\n";
cout << "*********************************\n";
break;
}
}while(ans != 9);
return 0;
}
ComputerLabs::ComputerLabs()
{
int column, row;
// User input
cout << "How many labs should I create?\nEnter an integer here: ";
cin >> column;
cout << "\nHow many computer should each lab have?\nEnter an integer here: ";
cin >> row;
cout << "\nCreating " << column << " labs and each lab will have " << row << " computers.\n";
// Dynamically create the vector of vectors here.
// Making a column by row vector of vector of strings.
for(int x = 0; x < column; x++)
{
// Make a new vector of strings
vector <string> newlab;
// Push the vector of strings into the lab vector
labs.push_back(newlab);
// Push back empty strings into that vector of strings.
for(int y = 0; y < row; y++)
{
labs[x].push_back("empty");
}
}
}
void ComputerLabs::show_labs(void)
{
// Print out these before the loop so they don't show up all the time.
cout << "\nComputer Lab Display System\n";
cout << "Labs:\tComputers:\n";
// This goes through and prints all the labs / computers out.
for(int x = 0; x < labs.size(); x++)
{
cout << x << ":\t";
for(int y = 0; y < labs[x].size(); y++)
{
cout << y << ": " << labs[x][y] << " ";
}
cout << endl;
}
}
void ComputerLabs::login(void)
{
string user_ID;
int lab_num, comp_num;
// User input
cout << "\nComputer Lab Login System\n";
cout << "Please enter your user ID: ";
cin >> user_ID;
cin.ignore();
cout << "Please enter the lab number: ";
cin >> lab_num;
cout << "Please enter the computer number: ";
cin >> comp_num;
// Check for errors first.
if(lab_num >= labs.size() || lab_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that lab number doesn't exist.\n";
// We alerted the user, so exit from this function.
return;
}
else if(comp_num >= labs[lab_num].size() || comp_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that computer number is too high to insert at.\n";
cout << "Comp number: " << comp_num << "lab number: " << lab_num << endl;
// We alerted the user, so exit from this function.
return;
}
// Set that user_ID to that specific computer
labs[lab_num][comp_num] = user_ID;
}
void ComputerLabs::logoff(void)
{
// User input
cout << "\nComputer Lab Logoff System\n";
string user_ID;
cout << "Please enter your user ID: ";
cin >> user_ID;
cin.ignore();
// Search for this user_ID
for(int x = 0; x < labs.size(); x++)
{
for(int y = 0; y < labs[x].size(); y++)
{
// We found the USER ID in the vector!
if(labs[x][y] == user_ID)
{
// Let the user know we're removing that ID, and then set that
// spot in the vector equal to "empty"
cout << "Removing " << user_ID << " from the computer system.\n";
labs[x][y] = "empty";
// Let's exit the function, since we found the user ID.
return;
}
}
}
// If we get here, we came up empty handed. :(
cout << "\nSorry, I couldn't find that user ID!\n";
}
void ComputerLabs::searchUser(void)
{
// User input
cout << "\nComputer Lab Search System\n";
string user_ID;
cout << "Please enter your user ID: ";
cin >> user_ID;
cin.ignore();
// Search for this user_ID
for(int x = 0; x < labs.size(); x++)
{
for(int y = 0; y < labs[x].size(); y++)
{
// We found the USER ID in the vector!
if(labs[x][y] == user_ID)
{
// We found it!
cout << "\nFound the user ID: " << user_ID << endl;
cout << "Currently logged into computer " << y << " in lab " << x << endl;
// Let's exit the function, since we found the user ID.
return;
}
}
}
// If we get here, we came up empty handed. :(
cout << "\nSorry, I couldn't find that user ID!\n";
}
void ComputerLabs::addLab(void)
{
int lab_num, comp_num;
// User input
cout << "\nComputer Lab Add Lab System\n";
cout << "Enter the position you'd like to add a lab at: ";
cin >> lab_num;
cout << "Enter the number of computers this lab should have: ";
cin >> comp_num;
// Check the bounds, make sure the number isn't too large or too small.
// The user should be able to insert a computer at the beginning, middle
// or very end of the vector.
if(lab_num > labs.size() || lab_num < 0)
{
// Too large or is a negative number.
cout << "\nSorry, that lab number is either too high to insert at\n";
cout << "or is a negative number.\n";
// We alerted the user, so exit from this function.
return;
}
// Make a new vector of strings
vector <string> newlab;
for(int y = 0; y < comp_num; y++)
{
newlab.push_back("empty");
}
// Rather using push_back, use insert to insert at a given position.
// This will push all the other labs forward one.
labs.insert(labs.begin() + lab_num, newlab);
}
void ComputerLabs::addComp(void)
{
int lab_num, comp_num;
// User input
cout << "\nComputer Lab Add Computer System\n";
cout << "Enter the lab you'd like to add a computer at: ";
cin >> lab_num;
cout << "Enter the position you'd like to insert the computer at: ";
cin >> comp_num;
// Check the bounds, make sure the number isn't too large or too small.
// The user should be able to insert a computer at the beginning, middle
// or very end of the vector.
if(lab_num > labs.size() || lab_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that lab number doesn't exist.\n";
// We alerted the user, so exit from this function.
return;
}
else if(comp_num > labs[lab_num].size() || comp_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that computer number is too high to insert at.\n";
// We alerted the user, so exit from this function.
return;
}
// Rather using push_back, use insert to insert at a given position.
// This will push all the other computers forward one.
labs[lab_num].insert(labs[lab_num].begin() + comp_num, "empty");
}
void ComputerLabs::removeLab(void)
{
int lab_num;
// User input
cout << "\nComputer Lab Remove Lab System\n";
cout << "Enter a lab to remove: ";
cin >> lab_num;
/*
Check the bounds
In general, we should make sure that the lab number / computer number is
less than the total size of the number of labs / computers minus 1.
One easy way to catch this is to see if the lab / computer number is greater than
or equal to size. If this is true, then the lab / computer does not exist.
Also, we can't have negative positions in vectors so check for negative numbers too.
*/
if(lab_num >= labs.size() || lab_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that lab number doesn't exist.\n";
// We alerted the user, so exit from this function.
return;
}
// If we get here, we're safe to remove the computer from the vector.
cout << "\nRemoving lab number " << lab_num << " from the computer system.\n";
// This will remove the given lab and push every other lab forward one.
labs.erase(labs.begin() + lab_num);
}
void ComputerLabs::removeComp(void)
{
int lab_num, comp_num;
// User input
cout << "\nComputer Lab Remove Computer System\n";
cout << "Enter a computer and its location to remove it.\n";
cout << "Enter the computer's lab number: ";
cin >> lab_num;
cout << "Enter the computer's number: ";
cin >> comp_num;
/*
Check the bounds
In general, we should make sure that the lab number / computer number is
less than the total size of the number of labs / computers minus 1.
One easy way to catch this is to see if the lab / computer number is greater than
or equal to size. If this is true, then the lab / computer does not exist.
Also, we can't have negative positions in vectors so check for negative numbers too.
*/
if(lab_num >= labs.size() || lab_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that lab number doesn't exist.\n";
// We alerted the user, so exit from this function.
return;
}
// Assuming the above didn't force us to quit, we can check the specific lab vector.
else if(comp_num >= labs[lab_num].size() || comp_num < 0)
{
// Too large, so it can't exist.
cout << "\nSorry, that computer number doesn't exist.\n";
// We alerted the user, so exit from this function.
return;
}
// If we get here, we're safe to remove the computer from the vector.
cout << "\nRemoving computer " << comp_num << " from lab number " << lab_num << ".\n";
// This will remove the given lab and push every other lab forward one.
labs[lab_num].erase(labs[lab_num].begin() + comp_num);
}
| 28.874408 | 98 | 0.527452 | DulceWRLD |
791e4b88363ac48304da1c6e6c60812aa023ba64 | 5,981 | hxx | C++ | main/xmlreader/inc/xmlreader/xmlreader.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 679 | 2015-01-06T06:34:58.000Z | 2022-03-30T01:06:03.000Z | main/xmlreader/inc/xmlreader/xmlreader.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 102 | 2017-11-07T08:51:31.000Z | 2022-03-17T12:13:49.000Z | main/xmlreader/inc/xmlreader/xmlreader.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 331 | 2015-01-06T11:40:55.000Z | 2022-03-14T04:07:51.000Z | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef INCLUDED_XMLREADER_XMLREADER_HXX
#define INCLUDED_XMLREADER_XMLREADER_HXX
#include "sal/config.h"
#include <stack>
#include <vector>
#include "boost/noncopyable.hpp"
#include "com/sun/star/container/NoSuchElementException.hpp"
#include "com/sun/star/uno/RuntimeException.hpp"
#include "osl/file.h"
#include "rtl/ustring.hxx"
#include "sal/types.h"
#include "xmlreader/detail/xmlreaderdllapi.hxx"
#include "xmlreader/pad.hxx"
#include "xmlreader/span.hxx"
namespace xmlreader {
class OOO_DLLPUBLIC_XMLREADER XmlReader: private boost::noncopyable {
public:
explicit XmlReader(rtl::OUString const & fileUrl)
SAL_THROW((
com::sun::star::container::NoSuchElementException,
com::sun::star::uno::RuntimeException));
~XmlReader();
enum { NAMESPACE_NONE = -2, NAMESPACE_UNKNOWN = -1, NAMESPACE_XML = 0 };
enum Text { TEXT_NONE, TEXT_RAW, TEXT_NORMALIZED };
enum Result { RESULT_BEGIN, RESULT_END, RESULT_TEXT, RESULT_DONE };
int registerNamespaceIri(Span const & iri);
// RESULT_BEGIN: data = localName, ns = ns
// RESULT_END: data, ns unused
// RESULT_TEXT: data = text, ns unused
Result nextItem(Text reportText, Span * data, int * nsId);
bool nextAttribute(int * nsId, Span * localName);
// the span returned by getAttributeValue is only valid until the next call
// to nextItem or getAttributeValue
Span getAttributeValue(bool fullyNormalize);
int getNamespaceId(Span const & prefix) const;
rtl::OUString getUrl() const;
private:
typedef std::vector< Span > NamespaceIris;
// If NamespaceData (and similarly ElementData and AttributeData) is made
// SAL_DLLPRIVATE, at least gcc 4.2.3 erroneously warns about
// "'xmlreader::XmlReader' declared with greater visibility than the type of
// its field 'xmlreader::XmlReader::namespaces_'" (and similarly for
// elements_ and attributes_):
struct NamespaceData {
Span prefix;
int nsId;
NamespaceData() {}
NamespaceData(Span const & thePrefix, int theNsId):
prefix(thePrefix), nsId(theNsId) {}
};
typedef std::vector< NamespaceData > NamespaceList;
struct ElementData {
Span name;
NamespaceList::size_type inheritedNamespaces;
int defaultNamespaceId;
ElementData(
Span const & theName,
NamespaceList::size_type theInheritedNamespaces,
int theDefaultNamespaceId):
name(theName), inheritedNamespaces(theInheritedNamespaces),
defaultNamespaceId(theDefaultNamespaceId)
{}
};
typedef std::stack< ElementData > ElementStack;
struct AttributeData {
char const * nameBegin;
char const * nameEnd;
char const * nameColon;
char const * valueBegin;
char const * valueEnd;
AttributeData(
char const * theNameBegin, char const * theNameEnd,
char const * theNameColon, char const * theValueBegin,
char const * theValueEnd):
nameBegin(theNameBegin), nameEnd(theNameEnd),
nameColon(theNameColon), valueBegin(theValueBegin),
valueEnd(theValueEnd)
{}
};
typedef std::vector< AttributeData > Attributes;
enum State {
STATE_CONTENT, STATE_START_TAG, STATE_END_TAG, STATE_EMPTY_ELEMENT_TAG,
STATE_DONE };
SAL_DLLPRIVATE inline char read() { return pos_ == end_ ? '\0' : *pos_++; }
SAL_DLLPRIVATE inline char peek() { return pos_ == end_ ? '\0' : *pos_; }
SAL_DLLPRIVATE void normalizeLineEnds(Span const & text);
SAL_DLLPRIVATE void skipSpace();
SAL_DLLPRIVATE bool skipComment();
SAL_DLLPRIVATE void skipProcessingInstruction();
SAL_DLLPRIVATE void skipDocumentTypeDeclaration();
SAL_DLLPRIVATE Span scanCdataSection();
SAL_DLLPRIVATE bool scanName(char const ** nameColon);
SAL_DLLPRIVATE int scanNamespaceIri(
char const * begin, char const * end);
SAL_DLLPRIVATE char const * handleReference(
char const * position, char const * end);
SAL_DLLPRIVATE Span handleAttributeValue(
char const * begin, char const * end, bool fullyNormalize);
SAL_DLLPRIVATE Result handleStartTag(int * nsId, Span * localName);
SAL_DLLPRIVATE Result handleEndTag();
SAL_DLLPRIVATE void handleElementEnd();
SAL_DLLPRIVATE Result handleSkippedText(Span * data, int * nsId);
SAL_DLLPRIVATE Result handleRawText(Span * text);
SAL_DLLPRIVATE Result handleNormalizedText(Span * text);
SAL_DLLPRIVATE int toNamespaceId(NamespaceIris::size_type pos);
rtl::OUString fileUrl_;
oslFileHandle fileHandle_;
sal_uInt64 fileSize_;
void * fileAddress_;
NamespaceIris namespaceIris_;
NamespaceList namespaces_;
ElementStack elements_;
char const * pos_;
char const * end_;
State state_;
Attributes attributes_;
Attributes::iterator currentAttribute_;
bool firstAttribute_;
Pad pad_;
};
}
#endif
| 30.515306 | 80 | 0.681324 | Grosskopf |
791f893820e1fda1d7684a2eff098374840d4a7e | 2,188 | cpp | C++ | cppcheck/data/c_files/13.cpp | awsm-research/LineVul | 246baf18c1932094564a10c9b81efb21914b2978 | [
"MIT"
] | 2 | 2022-03-23T12:16:20.000Z | 2022-03-31T06:19:40.000Z | cppcheck/data/c_files/13.cpp | awsm-research/LineVul | 246baf18c1932094564a10c9b81efb21914b2978 | [
"MIT"
] | null | null | null | cppcheck/data/c_files/13.cpp | awsm-research/LineVul | 246baf18c1932094564a10c9b81efb21914b2978 | [
"MIT"
] | null | null | null | IDNConversionResult IDNToUnicodeWithAdjustmentsImpl(
base::StringPiece host,
base::OffsetAdjuster::Adjustments* adjustments,
bool enable_spoof_checks) {
if (adjustments)
adjustments->clear();
// Convert the ASCII input to a base::string16 for ICU.
base::string16 input16;
input16.reserve(host.length());
input16.insert(input16.end(), host.begin(), host.end());
bool is_tld_ascii = true;
size_t last_dot = host.rfind('.');
if (last_dot != base::StringPiece::npos &&
host.substr(last_dot).starts_with(".xn--")) {
is_tld_ascii = false;
}
IDNConversionResult result;
// Do each component of the host separately, since we enforce script matching
// on a per-component basis.
base::string16 out16;
for (size_t component_start = 0, component_end;
component_start < input16.length();
component_start = component_end + 1) {
// Find the end of the component.
component_end = input16.find('.', component_start);
if (component_end == base::string16::npos)
component_end = input16.length(); // For getting the last component.
size_t component_length = component_end - component_start;
size_t new_component_start = out16.length();
bool converted_idn = false;
if (component_end > component_start) {
// Add the substring that we just found.
bool has_idn_component = false;
converted_idn = IDNToUnicodeOneComponent(
input16.data() + component_start, component_length, is_tld_ascii,
enable_spoof_checks, &out16, &has_idn_component);
result.has_idn_component |= has_idn_component;
}
size_t new_component_length = out16.length() - new_component_start;
if (converted_idn && adjustments) {
adjustments->push_back(base::OffsetAdjuster::Adjustment(
component_start, component_length, new_component_length));
}
// Need to add the dot we just found (if we found one).
if (component_end < input16.length())
out16.push_back('.');
}
result.result = out16;
// Leave as punycode any inputs that spoof top domains.
if (result.has_idn_component) {
result.matching_top_domain =
g_idn_spoof_checker.Get().GetSimilarTopDomain(out16);
if (enable_spoof_checks && !result.matching_top_domain.domain.empty()) {
if (adjustments)
adjustments->clear();
result.result = input16;
}
}
return result;
}
| 32.176471 | 77 | 0.762797 | awsm-research |
792136d98b549852f7f8776bf1bebc52c9f940be | 9,845 | cpp | C++ | src/odbc/Connection.cpp | mrylov/odbc-cpp-wrapper | c822bc036196aa1819ccf69a88556382eeae925f | [
"Apache-2.0"
] | 34 | 2019-02-25T14:43:58.000Z | 2022-03-14T17:15:44.000Z | src/odbc/Connection.cpp | mrylov/odbc-cpp-wrapper | c822bc036196aa1819ccf69a88556382eeae925f | [
"Apache-2.0"
] | 18 | 2019-05-14T10:00:09.000Z | 2022-03-14T17:15:05.000Z | src/odbc/Connection.cpp | mrylov/odbc-cpp-wrapper | c822bc036196aa1819ccf69a88556382eeae925f | [
"Apache-2.0"
] | 28 | 2019-05-14T09:25:30.000Z | 2022-03-18T04:21:21.000Z | #include <limits>
#include <odbc/Connection.h>
#include <odbc/DatabaseMetaData.h>
#include <odbc/DatabaseMetaDataUnicode.h>
#include <odbc/Environment.h>
#include <odbc/Exception.h>
#include <odbc/PreparedStatement.h>
#include <odbc/ResultSet.h>
#include <odbc/Statement.h>
#include <odbc/internal/Macros.h>
#include <odbc/internal/Odbc.h>
//------------------------------------------------------------------------------
using namespace std;
//------------------------------------------------------------------------------
namespace odbc {
//------------------------------------------------------------------------------
Connection::Connection(Environment* parent)
: parent_(parent, true)
, hdbc_(SQL_NULL_HANDLE)
, connected_(false)
{
}
//------------------------------------------------------------------------------
Connection::~Connection()
{
if (connected_)
SQLDisconnect(hdbc_);
if (hdbc_)
SQLFreeHandle(SQL_HANDLE_DBC, hdbc_);
}
//------------------------------------------------------------------------------
void Connection::setHandle(void* hdbc)
{
hdbc_ = hdbc;
}
//------------------------------------------------------------------------------
void Connection::connect(const char* dsn, const char* user,
const char* password)
{
EXEC_DBC(SQLConnectA, hdbc_,
(SQLCHAR*)dsn, SQL_NTS,
(SQLCHAR*)user, SQL_NTS,
(SQLCHAR*)password, SQL_NTS);
connected_ = true;
}
//------------------------------------------------------------------------------
void Connection::connect(const char* connString)
{
SQLCHAR outString[1024];
SQLSMALLINT outLength;
EXEC_DBC(SQLDriverConnectA, hdbc_, NULL,
(SQLCHAR*)connString, SQL_NTS,
outString, sizeof(outString),
&outLength, SQL_DRIVER_NOPROMPT);
connected_ = true;
}
//------------------------------------------------------------------------------
void Connection::disconnect()
{
SQLRETURN rc = SQLDisconnect(hdbc_);
connected_ = false;
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
}
//------------------------------------------------------------------------------
bool Connection::connected() const
{
return connected_;
}
//------------------------------------------------------------------------------
bool Connection::isValid()
{
SQLULEN ret = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_CONNECTION_DEAD, &ret, 0, NULL);
return ret == SQL_CD_FALSE;
}
//------------------------------------------------------------------------------
unsigned long Connection::getConnectionTimeout()
{
SQLULEN ret = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_CONNECTION_TIMEOUT, &ret, 0,
NULL);
return (unsigned long)ret;
}
//------------------------------------------------------------------------------
void Connection::setConnectionTimeout(unsigned long seconds)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, SQL_ATTR_CONNECTION_TIMEOUT,
(SQLPOINTER)(ptrdiff_t)seconds, SQL_IS_UINTEGER);
}
//------------------------------------------------------------------------------
unsigned long Connection::getLoginTimeout()
{
SQLULEN ret = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_LOGIN_TIMEOUT, &ret, 0, NULL);
return (unsigned long)ret;
}
//------------------------------------------------------------------------------
void Connection::setLoginTimeout(unsigned long seconds)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, SQL_ATTR_LOGIN_TIMEOUT,
(SQLPOINTER)(ptrdiff_t)seconds, SQL_IS_UINTEGER);
}
//------------------------------------------------------------------------------
void Connection::setAttribute(int attr, int value)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, attr, (SQLPOINTER)(ptrdiff_t)value,
SQL_IS_INTEGER);
}
//------------------------------------------------------------------------------
void Connection::setAttribute(int attr, unsigned int value)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, attr, (SQLPOINTER)(ptrdiff_t)value,
SQL_IS_UINTEGER);
}
//------------------------------------------------------------------------------
void Connection::setAttribute(int attr, const char* value)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, attr, (SQLPOINTER)value, SQL_NTS);
}
//------------------------------------------------------------------------------
void Connection::setAttribute(int attr, const char* value, std::size_t size)
{
if (size > (size_t)numeric_limits<SQLINTEGER>::max())
throw Exception("The attribute value is too long");
EXEC_DBC(SQLSetConnectAttr, hdbc_, attr, (SQLPOINTER)value,
(SQLINTEGER)size);
}
//------------------------------------------------------------------------------
void Connection::setAttribute(int attr, const void* value, std::size_t size)
{
if (size > (size_t)numeric_limits<SQLINTEGER>::max())
throw Exception("The attribute value is too long");
EXEC_DBC(SQLSetConnectAttr, hdbc_, attr, (SQLPOINTER)value,
(SQLINTEGER)size);
}
//------------------------------------------------------------------------------
bool Connection::getAutoCommit() const
{
SQLULEN ret = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_AUTOCOMMIT, &ret, 0, NULL);
return ret == SQL_AUTOCOMMIT_ON;
}
//------------------------------------------------------------------------------
void Connection::setAutoCommit(bool autoCommit)
{
EXEC_DBC(SQLSetConnectAttr, hdbc_, SQL_ATTR_AUTOCOMMIT,
autoCommit ?
(SQLPOINTER)SQL_AUTOCOMMIT_ON: (SQLPOINTER)SQL_AUTOCOMMIT_OFF,
SQL_IS_INTEGER);
}
//------------------------------------------------------------------------------
void Connection::commit()
{
SQLRETURN rc = SQLEndTran(SQL_HANDLE_DBC, hdbc_, SQL_COMMIT);
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
}
//------------------------------------------------------------------------------
void Connection::rollback()
{
SQLRETURN rc = SQLEndTran(SQL_HANDLE_DBC, hdbc_, SQL_ROLLBACK);
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
}
//------------------------------------------------------------------------------
bool Connection::isReadOnly()
{
SQLULEN ret = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_ACCESS_MODE, &ret, 0, NULL);
return ret == SQL_MODE_READ_ONLY;
}
//------------------------------------------------------------------------------
void Connection::setReadOnly(bool readOnly)
{
unsigned int mode = readOnly ? SQL_MODE_READ_ONLY : SQL_MODE_READ_WRITE;
setAttribute(SQL_ATTR_ACCESS_MODE, mode);
}
//------------------------------------------------------------------------------
TransactionIsolationLevel Connection::getTransactionIsolation()
{
SQLULEN txn = 0;
EXEC_DBC(SQLGetConnectAttr, hdbc_, SQL_ATTR_TXN_ISOLATION, &txn, 0, NULL);
switch (txn)
{
case SQL_TXN_READ_COMMITTED:
return TransactionIsolationLevel::READ_COMMITTED;
case SQL_TXN_READ_UNCOMMITTED:
return TransactionIsolationLevel::READ_UNCOMMITTED;
case SQL_TXN_REPEATABLE_READ:
return TransactionIsolationLevel::REPEATABLE_READ;
case SQL_TXN_SERIALIZABLE:
return TransactionIsolationLevel::SERIALIZABLE;
case 0:
return TransactionIsolationLevel::NONE;
default:
throw Exception("Unknown transaction isolation level.");
}
}
//------------------------------------------------------------------------------
void Connection::setTransactionIsolation(TransactionIsolationLevel level)
{
unsigned int txn = 0;
switch (level)
{
case TransactionIsolationLevel::READ_COMMITTED:
txn = SQL_TXN_READ_COMMITTED;
break;
case TransactionIsolationLevel::READ_UNCOMMITTED:
txn = SQL_TXN_READ_UNCOMMITTED;
break;
case TransactionIsolationLevel::REPEATABLE_READ:
txn = SQL_TXN_REPEATABLE_READ;
break;
case TransactionIsolationLevel::SERIALIZABLE:
txn = SQL_TXN_SERIALIZABLE;
break;
case TransactionIsolationLevel::NONE:
throw Exception("NONE transaction isolation level cannot be set.");
}
setAttribute(SQL_ATTR_TXN_ISOLATION, txn);
}
//------------------------------------------------------------------------------
StatementRef Connection::createStatement()
{
SQLHANDLE hstmt;
StatementRef ret(new Statement(this));
SQLRETURN rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc_, &hstmt);
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
ret->setHandle(hstmt);
return ret;
}
//------------------------------------------------------------------------------
PreparedStatementRef Connection::prepareStatement(const char* sql)
{
SQLHANDLE hstmt;
PreparedStatementRef ret(new PreparedStatement(this));
SQLRETURN rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc_, &hstmt);
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
ret->setHandleAndQuery(hstmt, sql);
return ret;
}
//------------------------------------------------------------------------------
PreparedStatementRef Connection::prepareStatement(const char16_t* sql)
{
SQLHANDLE hstmt;
PreparedStatementRef ret(new PreparedStatement(this));
SQLRETURN rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc_, &hstmt);
Exception::checkForError(rc, SQL_HANDLE_DBC, hdbc_);
ret->setHandleAndQuery(hstmt, sql);
return ret;
}
//------------------------------------------------------------------------------
DatabaseMetaDataRef Connection::getDatabaseMetaData()
{
DatabaseMetaDataRef ret(new DatabaseMetaData(this));
return ret;
}
//------------------------------------------------------------------------------
DatabaseMetaDataUnicodeRef Connection::getDatabaseMetaDataUnicode()
{
DatabaseMetaDataUnicodeRef ret(new DatabaseMetaDataUnicode(this));
return ret;
}
//------------------------------------------------------------------------------
} // namespace odbc
| 37.011278 | 80 | 0.528085 | mrylov |
792273d865dd48c6e4851aaa7e72ca73121c7e56 | 26,275 | cc | C++ | src/cxx/default_ast_visitor.cc | robertoraggi/cplusplus | d15d4669629a7cc0347ea7ed60697b55cbd44523 | [
"MIT"
] | 49 | 2015-03-08T11:28:28.000Z | 2021-11-29T14:23:39.000Z | src/cxx/default_ast_visitor.cc | robertoraggi/cplusplus | d15d4669629a7cc0347ea7ed60697b55cbd44523 | [
"MIT"
] | 19 | 2021-03-06T05:14:02.000Z | 2021-12-02T19:48:07.000Z | src/cxx/default_ast_visitor.cc | robertoraggi/cplusplus | d15d4669629a7cc0347ea7ed60697b55cbd44523 | [
"MIT"
] | 10 | 2015-01-08T16:08:49.000Z | 2022-01-27T06:42:51.000Z | // Copyright (c) 2021 Roberto Raggi <roberto.raggi@gmail.com>
//
// 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 <cxx/ast.h>
#include <cxx/default_ast_visitor.h>
#include <stdexcept>
namespace cxx {
// AST
void DefaultASTVisitor::visit(TypeIdAST* ast) {
throw std::runtime_error("visit(TypeIdAST): not implemented");
}
void DefaultASTVisitor::visit(NestedNameSpecifierAST* ast) {
throw std::runtime_error("visit(NestedNameSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(UsingDeclaratorAST* ast) {
throw std::runtime_error("visit(UsingDeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(HandlerAST* ast) {
throw std::runtime_error("visit(HandlerAST): not implemented");
}
void DefaultASTVisitor::visit(EnumBaseAST* ast) {
throw std::runtime_error("visit(EnumBaseAST): not implemented");
}
void DefaultASTVisitor::visit(EnumeratorAST* ast) {
throw std::runtime_error("visit(EnumeratorAST): not implemented");
}
void DefaultASTVisitor::visit(DeclaratorAST* ast) {
throw std::runtime_error("visit(DeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(InitDeclaratorAST* ast) {
throw std::runtime_error("visit(InitDeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(BaseSpecifierAST* ast) {
throw std::runtime_error("visit(BaseSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(BaseClauseAST* ast) {
throw std::runtime_error("visit(BaseClauseAST): not implemented");
}
void DefaultASTVisitor::visit(NewTypeIdAST* ast) {
throw std::runtime_error("visit(NewTypeIdAST): not implemented");
}
void DefaultASTVisitor::visit(RequiresClauseAST* ast) {
throw std::runtime_error("visit(RequiresClauseAST): not implemented");
}
void DefaultASTVisitor::visit(ParameterDeclarationClauseAST* ast) {
throw std::runtime_error(
"visit(ParameterDeclarationClauseAST): not implemented");
}
void DefaultASTVisitor::visit(ParametersAndQualifiersAST* ast) {
throw std::runtime_error(
"visit(ParametersAndQualifiersAST): not implemented");
}
void DefaultASTVisitor::visit(LambdaIntroducerAST* ast) {
throw std::runtime_error("visit(LambdaIntroducerAST): not implemented");
}
void DefaultASTVisitor::visit(LambdaDeclaratorAST* ast) {
throw std::runtime_error("visit(LambdaDeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(TrailingReturnTypeAST* ast) {
throw std::runtime_error("visit(TrailingReturnTypeAST): not implemented");
}
void DefaultASTVisitor::visit(CtorInitializerAST* ast) {
throw std::runtime_error("visit(CtorInitializerAST): not implemented");
}
void DefaultASTVisitor::visit(RequirementBodyAST* ast) {
throw std::runtime_error("visit(RequirementBodyAST): not implemented");
}
void DefaultASTVisitor::visit(TypeConstraintAST* ast) {
throw std::runtime_error("visit(TypeConstraintAST): not implemented");
}
// RequirementAST
void DefaultASTVisitor::visit(SimpleRequirementAST* ast) {
throw std::runtime_error("visit(SimpleRequirementAST): not implemented");
}
void DefaultASTVisitor::visit(CompoundRequirementAST* ast) {
throw std::runtime_error("visit(CompoundRequirementAST): not implemented");
}
void DefaultASTVisitor::visit(TypeRequirementAST* ast) {
throw std::runtime_error("visit(TypeRequirementAST): not implemented");
}
void DefaultASTVisitor::visit(NestedRequirementAST* ast) {
throw std::runtime_error("visit(NestedRequirementAST): not implemented");
}
// TemplateArgumentAST
void DefaultASTVisitor::visit(TypeTemplateArgumentAST* ast) {
throw std::runtime_error("visit(TypeTemplateArgumentAST): not implemented");
}
void DefaultASTVisitor::visit(ExpressionTemplateArgumentAST* ast) {
throw std::runtime_error(
"visit(ExpressionTemplateArgumentAST): not implemented");
}
// MemInitializerAST
void DefaultASTVisitor::visit(ParenMemInitializerAST* ast) {
throw std::runtime_error("visit(ParenMemInitializerAST): not implemented");
}
void DefaultASTVisitor::visit(BracedMemInitializerAST* ast) {
throw std::runtime_error("visit(BracedMemInitializerAST): not implemented");
}
// LambdaCaptureAST
void DefaultASTVisitor::visit(ThisLambdaCaptureAST* ast) {
throw std::runtime_error("visit(ThisLambdaCaptureAST): not implemented");
}
void DefaultASTVisitor::visit(DerefThisLambdaCaptureAST* ast) {
throw std::runtime_error("visit(DerefThisLambdaCaptureAST): not implemented");
}
void DefaultASTVisitor::visit(SimpleLambdaCaptureAST* ast) {
throw std::runtime_error("visit(SimpleLambdaCaptureAST): not implemented");
}
void DefaultASTVisitor::visit(RefLambdaCaptureAST* ast) {
throw std::runtime_error("visit(RefLambdaCaptureAST): not implemented");
}
void DefaultASTVisitor::visit(RefInitLambdaCaptureAST* ast) {
throw std::runtime_error("visit(RefInitLambdaCaptureAST): not implemented");
}
void DefaultASTVisitor::visit(InitLambdaCaptureAST* ast) {
throw std::runtime_error("visit(InitLambdaCaptureAST): not implemented");
}
// InitializerAST
void DefaultASTVisitor::visit(EqualInitializerAST* ast) {
throw std::runtime_error("visit(EqualInitializerAST): not implemented");
}
void DefaultASTVisitor::visit(BracedInitListAST* ast) {
throw std::runtime_error("visit(BracedInitListAST): not implemented");
}
void DefaultASTVisitor::visit(ParenInitializerAST* ast) {
throw std::runtime_error("visit(ParenInitializerAST): not implemented");
}
// NewInitializerAST
void DefaultASTVisitor::visit(NewParenInitializerAST* ast) {
throw std::runtime_error("visit(NewParenInitializerAST): not implemented");
}
void DefaultASTVisitor::visit(NewBracedInitializerAST* ast) {
throw std::runtime_error("visit(NewBracedInitializerAST): not implemented");
}
// ExceptionDeclarationAST
void DefaultASTVisitor::visit(EllipsisExceptionDeclarationAST* ast) {
throw std::runtime_error(
"visit(EllipsisExceptionDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(TypeExceptionDeclarationAST* ast) {
throw std::runtime_error(
"visit(TypeExceptionDeclarationAST): not implemented");
}
// FunctionBodyAST
void DefaultASTVisitor::visit(DefaultFunctionBodyAST* ast) {
throw std::runtime_error("visit(DefaultFunctionBodyAST): not implemented");
}
void DefaultASTVisitor::visit(CompoundStatementFunctionBodyAST* ast) {
throw std::runtime_error(
"visit(CompoundStatementFunctionBodyAST): not implemented");
}
void DefaultASTVisitor::visit(TryStatementFunctionBodyAST* ast) {
throw std::runtime_error(
"visit(TryStatementFunctionBodyAST): not implemented");
}
void DefaultASTVisitor::visit(DeleteFunctionBodyAST* ast) {
throw std::runtime_error("visit(DeleteFunctionBodyAST): not implemented");
}
// UnitAST
void DefaultASTVisitor::visit(TranslationUnitAST* ast) {
throw std::runtime_error("visit(TranslationUnitAST): not implemented");
}
void DefaultASTVisitor::visit(ModuleUnitAST* ast) {
throw std::runtime_error("visit(ModuleUnitAST): not implemented");
}
// ExpressionAST
void DefaultASTVisitor::visit(ThisExpressionAST* ast) {
throw std::runtime_error("visit(ThisExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(CharLiteralExpressionAST* ast) {
throw std::runtime_error("visit(CharLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(BoolLiteralExpressionAST* ast) {
throw std::runtime_error("visit(BoolLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(IntLiteralExpressionAST* ast) {
throw std::runtime_error("visit(IntLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(FloatLiteralExpressionAST* ast) {
throw std::runtime_error("visit(FloatLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(NullptrLiteralExpressionAST* ast) {
throw std::runtime_error(
"visit(NullptrLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(StringLiteralExpressionAST* ast) {
throw std::runtime_error(
"visit(StringLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(UserDefinedStringLiteralExpressionAST* ast) {
throw std::runtime_error(
"visit(UserDefinedStringLiteralExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(IdExpressionAST* ast) {
throw std::runtime_error("visit(IdExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(RequiresExpressionAST* ast) {
throw std::runtime_error("visit(RequiresExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(NestedExpressionAST* ast) {
throw std::runtime_error("visit(NestedExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(RightFoldExpressionAST* ast) {
throw std::runtime_error("visit(RightFoldExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(LeftFoldExpressionAST* ast) {
throw std::runtime_error("visit(LeftFoldExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(FoldExpressionAST* ast) {
throw std::runtime_error("visit(FoldExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(LambdaExpressionAST* ast) {
throw std::runtime_error("visit(LambdaExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(SizeofExpressionAST* ast) {
throw std::runtime_error("visit(SizeofExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(SizeofTypeExpressionAST* ast) {
throw std::runtime_error("visit(SizeofTypeExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(SizeofPackExpressionAST* ast) {
throw std::runtime_error("visit(SizeofPackExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(TypeidExpressionAST* ast) {
throw std::runtime_error("visit(TypeidExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(TypeidOfTypeExpressionAST* ast) {
throw std::runtime_error("visit(TypeidOfTypeExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(AlignofExpressionAST* ast) {
throw std::runtime_error("visit(AlignofExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(UnaryExpressionAST* ast) {
throw std::runtime_error("visit(UnaryExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(BinaryExpressionAST* ast) {
throw std::runtime_error("visit(BinaryExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(AssignmentExpressionAST* ast) {
throw std::runtime_error("visit(AssignmentExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(BracedTypeConstructionAST* ast) {
throw std::runtime_error("visit(BracedTypeConstructionAST): not implemented");
}
void DefaultASTVisitor::visit(TypeConstructionAST* ast) {
throw std::runtime_error("visit(TypeConstructionAST): not implemented");
}
void DefaultASTVisitor::visit(CallExpressionAST* ast) {
throw std::runtime_error("visit(CallExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(SubscriptExpressionAST* ast) {
throw std::runtime_error("visit(SubscriptExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(MemberExpressionAST* ast) {
throw std::runtime_error("visit(MemberExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(PostIncrExpressionAST* ast) {
throw std::runtime_error("visit(PostIncrExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(ConditionalExpressionAST* ast) {
throw std::runtime_error("visit(ConditionalExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(ImplicitCastExpressionAST* ast) {
throw std::runtime_error("visit(ImplicitCastExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(CastExpressionAST* ast) {
throw std::runtime_error("visit(CastExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(CppCastExpressionAST* ast) {
throw std::runtime_error("visit(CppCastExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(NewExpressionAST* ast) {
throw std::runtime_error("visit(NewExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(DeleteExpressionAST* ast) {
throw std::runtime_error("visit(DeleteExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(ThrowExpressionAST* ast) {
throw std::runtime_error("visit(ThrowExpressionAST): not implemented");
}
void DefaultASTVisitor::visit(NoexceptExpressionAST* ast) {
throw std::runtime_error("visit(NoexceptExpressionAST): not implemented");
}
// StatementAST
void DefaultASTVisitor::visit(LabeledStatementAST* ast) {
throw std::runtime_error("visit(LabeledStatementAST): not implemented");
}
void DefaultASTVisitor::visit(CaseStatementAST* ast) {
throw std::runtime_error("visit(CaseStatementAST): not implemented");
}
void DefaultASTVisitor::visit(DefaultStatementAST* ast) {
throw std::runtime_error("visit(DefaultStatementAST): not implemented");
}
void DefaultASTVisitor::visit(ExpressionStatementAST* ast) {
throw std::runtime_error("visit(ExpressionStatementAST): not implemented");
}
void DefaultASTVisitor::visit(CompoundStatementAST* ast) {
throw std::runtime_error("visit(CompoundStatementAST): not implemented");
}
void DefaultASTVisitor::visit(IfStatementAST* ast) {
throw std::runtime_error("visit(IfStatementAST): not implemented");
}
void DefaultASTVisitor::visit(SwitchStatementAST* ast) {
throw std::runtime_error("visit(SwitchStatementAST): not implemented");
}
void DefaultASTVisitor::visit(WhileStatementAST* ast) {
throw std::runtime_error("visit(WhileStatementAST): not implemented");
}
void DefaultASTVisitor::visit(DoStatementAST* ast) {
throw std::runtime_error("visit(DoStatementAST): not implemented");
}
void DefaultASTVisitor::visit(ForRangeStatementAST* ast) {
throw std::runtime_error("visit(ForRangeStatementAST): not implemented");
}
void DefaultASTVisitor::visit(ForStatementAST* ast) {
throw std::runtime_error("visit(ForStatementAST): not implemented");
}
void DefaultASTVisitor::visit(BreakStatementAST* ast) {
throw std::runtime_error("visit(BreakStatementAST): not implemented");
}
void DefaultASTVisitor::visit(ContinueStatementAST* ast) {
throw std::runtime_error("visit(ContinueStatementAST): not implemented");
}
void DefaultASTVisitor::visit(ReturnStatementAST* ast) {
throw std::runtime_error("visit(ReturnStatementAST): not implemented");
}
void DefaultASTVisitor::visit(GotoStatementAST* ast) {
throw std::runtime_error("visit(GotoStatementAST): not implemented");
}
void DefaultASTVisitor::visit(CoroutineReturnStatementAST* ast) {
throw std::runtime_error(
"visit(CoroutineReturnStatementAST): not implemented");
}
void DefaultASTVisitor::visit(DeclarationStatementAST* ast) {
throw std::runtime_error("visit(DeclarationStatementAST): not implemented");
}
void DefaultASTVisitor::visit(TryBlockStatementAST* ast) {
throw std::runtime_error("visit(TryBlockStatementAST): not implemented");
}
// DeclarationAST
void DefaultASTVisitor::visit(AccessDeclarationAST* ast) {
throw std::runtime_error("visit(AccessDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(FunctionDefinitionAST* ast) {
throw std::runtime_error("visit(FunctionDefinitionAST): not implemented");
}
void DefaultASTVisitor::visit(ConceptDefinitionAST* ast) {
throw std::runtime_error("visit(ConceptDefinitionAST): not implemented");
}
void DefaultASTVisitor::visit(ForRangeDeclarationAST* ast) {
throw std::runtime_error("visit(ForRangeDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(AliasDeclarationAST* ast) {
throw std::runtime_error("visit(AliasDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(SimpleDeclarationAST* ast) {
throw std::runtime_error("visit(SimpleDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(StaticAssertDeclarationAST* ast) {
throw std::runtime_error(
"visit(StaticAssertDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(EmptyDeclarationAST* ast) {
throw std::runtime_error("visit(EmptyDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(AttributeDeclarationAST* ast) {
throw std::runtime_error("visit(AttributeDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(OpaqueEnumDeclarationAST* ast) {
throw std::runtime_error("visit(OpaqueEnumDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(UsingEnumDeclarationAST* ast) {
throw std::runtime_error("visit(UsingEnumDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(NamespaceDefinitionAST* ast) {
throw std::runtime_error("visit(NamespaceDefinitionAST): not implemented");
}
void DefaultASTVisitor::visit(NamespaceAliasDefinitionAST* ast) {
throw std::runtime_error(
"visit(NamespaceAliasDefinitionAST): not implemented");
}
void DefaultASTVisitor::visit(UsingDirectiveAST* ast) {
throw std::runtime_error("visit(UsingDirectiveAST): not implemented");
}
void DefaultASTVisitor::visit(UsingDeclarationAST* ast) {
throw std::runtime_error("visit(UsingDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(AsmDeclarationAST* ast) {
throw std::runtime_error("visit(AsmDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(ExportDeclarationAST* ast) {
throw std::runtime_error("visit(ExportDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(ModuleImportDeclarationAST* ast) {
throw std::runtime_error(
"visit(ModuleImportDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(TemplateDeclarationAST* ast) {
throw std::runtime_error("visit(TemplateDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(TypenameTypeParameterAST* ast) {
throw std::runtime_error("visit(TypenameTypeParameterAST): not implemented");
}
void DefaultASTVisitor::visit(TypenamePackTypeParameterAST* ast) {
throw std::runtime_error(
"visit(TypenamePackTypeParameterAST): not implemented");
}
void DefaultASTVisitor::visit(TemplateTypeParameterAST* ast) {
throw std::runtime_error("visit(TemplateTypeParameterAST): not implemented");
}
void DefaultASTVisitor::visit(TemplatePackTypeParameterAST* ast) {
throw std::runtime_error(
"visit(TemplatePackTypeParameterAST): not implemented");
}
void DefaultASTVisitor::visit(DeductionGuideAST* ast) {
throw std::runtime_error("visit(DeductionGuideAST): not implemented");
}
void DefaultASTVisitor::visit(ExplicitInstantiationAST* ast) {
throw std::runtime_error("visit(ExplicitInstantiationAST): not implemented");
}
void DefaultASTVisitor::visit(ParameterDeclarationAST* ast) {
throw std::runtime_error("visit(ParameterDeclarationAST): not implemented");
}
void DefaultASTVisitor::visit(LinkageSpecificationAST* ast) {
throw std::runtime_error("visit(LinkageSpecificationAST): not implemented");
}
// NameAST
void DefaultASTVisitor::visit(SimpleNameAST* ast) {
throw std::runtime_error("visit(SimpleNameAST): not implemented");
}
void DefaultASTVisitor::visit(DestructorNameAST* ast) {
throw std::runtime_error("visit(DestructorNameAST): not implemented");
}
void DefaultASTVisitor::visit(DecltypeNameAST* ast) {
throw std::runtime_error("visit(DecltypeNameAST): not implemented");
}
void DefaultASTVisitor::visit(OperatorNameAST* ast) {
throw std::runtime_error("visit(OperatorNameAST): not implemented");
}
void DefaultASTVisitor::visit(ConversionNameAST* ast) {
throw std::runtime_error("visit(ConversionNameAST): not implemented");
}
void DefaultASTVisitor::visit(TemplateNameAST* ast) {
throw std::runtime_error("visit(TemplateNameAST): not implemented");
}
void DefaultASTVisitor::visit(QualifiedNameAST* ast) {
throw std::runtime_error("visit(QualifiedNameAST): not implemented");
}
// SpecifierAST
void DefaultASTVisitor::visit(TypedefSpecifierAST* ast) {
throw std::runtime_error("visit(TypedefSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(FriendSpecifierAST* ast) {
throw std::runtime_error("visit(FriendSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ConstevalSpecifierAST* ast) {
throw std::runtime_error("visit(ConstevalSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ConstinitSpecifierAST* ast) {
throw std::runtime_error("visit(ConstinitSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ConstexprSpecifierAST* ast) {
throw std::runtime_error("visit(ConstexprSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(InlineSpecifierAST* ast) {
throw std::runtime_error("visit(InlineSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(StaticSpecifierAST* ast) {
throw std::runtime_error("visit(StaticSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ExternSpecifierAST* ast) {
throw std::runtime_error("visit(ExternSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ThreadLocalSpecifierAST* ast) {
throw std::runtime_error("visit(ThreadLocalSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ThreadSpecifierAST* ast) {
throw std::runtime_error("visit(ThreadSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(MutableSpecifierAST* ast) {
throw std::runtime_error("visit(MutableSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(VirtualSpecifierAST* ast) {
throw std::runtime_error("visit(VirtualSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ExplicitSpecifierAST* ast) {
throw std::runtime_error("visit(ExplicitSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(AutoTypeSpecifierAST* ast) {
throw std::runtime_error("visit(AutoTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(VoidTypeSpecifierAST* ast) {
throw std::runtime_error("visit(VoidTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(VaListTypeSpecifierAST* ast) {
throw std::runtime_error("visit(VaListTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(IntegralTypeSpecifierAST* ast) {
throw std::runtime_error("visit(IntegralTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(FloatingPointTypeSpecifierAST* ast) {
throw std::runtime_error(
"visit(FloatingPointTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ComplexTypeSpecifierAST* ast) {
throw std::runtime_error("visit(ComplexTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(NamedTypeSpecifierAST* ast) {
throw std::runtime_error("visit(NamedTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(AtomicTypeSpecifierAST* ast) {
throw std::runtime_error("visit(AtomicTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(UnderlyingTypeSpecifierAST* ast) {
throw std::runtime_error(
"visit(UnderlyingTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ElaboratedTypeSpecifierAST* ast) {
throw std::runtime_error(
"visit(ElaboratedTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(DecltypeAutoSpecifierAST* ast) {
throw std::runtime_error("visit(DecltypeAutoSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(DecltypeSpecifierAST* ast) {
throw std::runtime_error("visit(DecltypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(TypeofSpecifierAST* ast) {
throw std::runtime_error("visit(TypeofSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(PlaceholderTypeSpecifierAST* ast) {
throw std::runtime_error(
"visit(PlaceholderTypeSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ConstQualifierAST* ast) {
throw std::runtime_error("visit(ConstQualifierAST): not implemented");
}
void DefaultASTVisitor::visit(VolatileQualifierAST* ast) {
throw std::runtime_error("visit(VolatileQualifierAST): not implemented");
}
void DefaultASTVisitor::visit(RestrictQualifierAST* ast) {
throw std::runtime_error("visit(RestrictQualifierAST): not implemented");
}
void DefaultASTVisitor::visit(EnumSpecifierAST* ast) {
throw std::runtime_error("visit(EnumSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(ClassSpecifierAST* ast) {
throw std::runtime_error("visit(ClassSpecifierAST): not implemented");
}
void DefaultASTVisitor::visit(TypenameSpecifierAST* ast) {
throw std::runtime_error("visit(TypenameSpecifierAST): not implemented");
}
// CoreDeclaratorAST
void DefaultASTVisitor::visit(IdDeclaratorAST* ast) {
throw std::runtime_error("visit(IdDeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(NestedDeclaratorAST* ast) {
throw std::runtime_error("visit(NestedDeclaratorAST): not implemented");
}
// PtrOperatorAST
void DefaultASTVisitor::visit(PointerOperatorAST* ast) {
throw std::runtime_error("visit(PointerOperatorAST): not implemented");
}
void DefaultASTVisitor::visit(ReferenceOperatorAST* ast) {
throw std::runtime_error("visit(ReferenceOperatorAST): not implemented");
}
void DefaultASTVisitor::visit(PtrToMemberOperatorAST* ast) {
throw std::runtime_error("visit(PtrToMemberOperatorAST): not implemented");
}
// DeclaratorModifierAST
void DefaultASTVisitor::visit(FunctionDeclaratorAST* ast) {
throw std::runtime_error("visit(FunctionDeclaratorAST): not implemented");
}
void DefaultASTVisitor::visit(ArrayDeclaratorAST* ast) {
throw std::runtime_error("visit(ArrayDeclaratorAST): not implemented");
}
} // namespace cxx
| 33.903226 | 80 | 0.785157 | robertoraggi |
79281997d74c5cdf149f60a6e24a5d9d51ac2c10 | 27,512 | cpp | C++ | modules/gdextensions/visual/bullet_manager.cpp | ppiecuch/godot | ff2098b324b814a0d1bd9d5722aa871fc5214fab | [
"MIT",
"Apache-2.0",
"CC-BY-4.0",
"Unlicense"
] | null | null | null | modules/gdextensions/visual/bullet_manager.cpp | ppiecuch/godot | ff2098b324b814a0d1bd9d5722aa871fc5214fab | [
"MIT",
"Apache-2.0",
"CC-BY-4.0",
"Unlicense"
] | null | null | null | modules/gdextensions/visual/bullet_manager.cpp | ppiecuch/godot | ff2098b324b814a0d1bd9d5722aa871fc5214fab | [
"MIT",
"Apache-2.0",
"CC-BY-4.0",
"Unlicense"
] | null | null | null | /*************************************************************************/
/* bullet_manager.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* 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 "bullet_manager.h"
#include "core/os/os.h"
#include "scene/2d/area_2d.h"
#include "scene/2d/collision_shape_2d.h"
#include "scene/main/scene_tree.h"
#include "scene/main/viewport.h"
#include "scene/scene_string_names.h"
void BulletManagerBullet::set_position(Point2 position) {
matrix.set_origin(position);
}
Point2 BulletManagerBullet::get_position() const {
return matrix.get_origin();
}
void BulletManagerBullet::set_direction(Vector2 direction) {
this->direction = direction;
if (this->type->is_rotating_physics()) {
this->matrix.set_rotation(direction.angle());
}
}
Vector2 BulletManagerBullet::get_direction() const {
return direction;
}
void BulletManagerBullet::set_angle(real_t angle) {
real_t rads = Math::deg2rad(angle);
this->direction = Vector2(cos(rads), sin(rads));
if (this->type->is_rotating_physics()) {
this->matrix.set_rotation(rads);
}
}
real_t BulletManagerBullet::get_angle() const {
return Math::rad2deg(direction.angle());
}
void BulletManagerBullet::set_speed(real_t speed) {
this->speed = speed;
}
real_t BulletManagerBullet::get_speed() const {
return speed;
}
void BulletManagerBullet::queue_delete() {
is_queued_for_deletion = true;
}
Node *BulletManagerBullet::get_type() const {
return type;
}
void BulletManagerBulletType::set_texture(const Ref<Texture> &p_texture) {
if (p_texture == texture)
return;
if (texture.is_valid())
texture->remove_change_receptor(this);
texture = p_texture;
if (texture.is_valid())
texture->add_change_receptor(this);
#ifdef TOOLS_ENABLED
update();
emit_signal("texture_changed");
item_rect_changed();
#endif
_change_notify("texture");
}
Ref<Texture> BulletManagerBulletType::get_texture() const {
return texture;
}
void BulletManagerBulletType::set_normal_map(const Ref<Texture> &p_normal_map) {
if (p_normal_map == normal_map)
return;
if (normal_map.is_valid())
texture->remove_change_receptor(this);
normal_map = p_normal_map;
if (normal_map.is_valid())
normal_map->add_change_receptor(this);
#ifdef TOOLS_ENABLED
update();
emit_signal("texture_changed");
item_rect_changed();
#endif
_change_notify("normal_map");
}
Ref<Texture> BulletManagerBulletType::get_normal_map() const {
return normal_map;
}
void BulletManagerBulletType::set_vframes(int p_amount) {
ERR_FAIL_COND(p_amount < 1);
vframes = p_amount;
_change_notify();
}
int BulletManagerBulletType::get_vframes() const {
return vframes;
}
void BulletManagerBulletType::set_hframes(int p_amount) {
ERR_FAIL_COND(p_amount < 1);
hframes = p_amount;
_change_notify();
}
int BulletManagerBulletType::get_hframes() const {
return hframes;
}
void BulletManagerBulletType::set_frame(int p_frame) {
ERR_FAIL_INDEX(p_frame, vframes * hframes);
frame = p_frame;
_change_notify("frame");
}
int BulletManagerBulletType::get_frame() const {
return frame;
}
void BulletManagerBulletType::set_centered(bool p_center) {
centered = p_center;
_change_notify();
}
bool BulletManagerBulletType::is_centered() const {
return centered;
}
void BulletManagerBulletType::set_offset(const Point2 &p_offset) {
offset = p_offset;
}
Point2 BulletManagerBulletType::get_offset() const {
return offset;
}
void BulletManagerBulletType::set_region(bool p_region) {
region = p_region;
_change_notify();
}
bool BulletManagerBulletType::is_region() const {
return region;
}
void BulletManagerBulletType::set_region_rect(const Rect2 &p_region_rec) {
region_rect = p_region_rec;
_change_notify();
}
Rect2 BulletManagerBulletType::get_region_rect() const {
return region_rect;
}
void BulletManagerBulletType::set_rotate_visual(bool p_rotate_visual) {
rotate_visual = p_rotate_visual;
_change_notify();
}
bool BulletManagerBulletType::is_rotating_visual() const {
return rotate_visual;
}
void BulletManagerBulletType::set_collision_shape(const Ref<Shape2D> &p_shape) {
if (collision_shape.is_valid()) {
collision_shape->disconnect("changed", this, "_shape_changed");
}
collision_shape = p_shape;
if (collision_shape.is_valid()) {
collision_shape->connect("changed", this, "_shape_changed");
}
_change_notify();
}
Ref<Shape2D> BulletManagerBulletType::get_collision_shape() const {
return collision_shape;
}
void BulletManagerBulletType::set_collision_mask(uint32_t p_mask) {
collision_mask = p_mask;
Physics2DServer::get_singleton()->area_set_collision_mask(area, collision_mask);
}
uint32_t BulletManagerBulletType::get_collision_mask() const {
return collision_mask;
}
void BulletManagerBulletType::set_collision_layer(uint32_t p_layer) {
collision_layer = p_layer;
Physics2DServer::get_singleton()->area_set_collision_layer(area, collision_layer);
}
uint32_t BulletManagerBulletType::get_collision_layer() const {
return collision_layer;
}
void BulletManagerBulletType::set_rotate_physics(bool p_rotate_physics) {
rotate_physics = p_rotate_physics;
}
bool BulletManagerBulletType::is_rotating_physics() const {
return rotate_physics;
}
void BulletManagerBulletType::_update_cached_rects() {
Rect2 base_rect;
if (region) {
base_rect = region_rect;
} else {
base_rect = Rect2(0, 0, texture->get_width(), texture->get_height());
}
Size2 frame_size = base_rect.size / Size2(hframes, vframes);
Point2 frame_offset = Point2(frame % hframes, frame / hframes);
frame_offset *= frame_size;
_cached_src_rect.size = frame_size;
_cached_src_rect.position = base_rect.position + frame_offset;
Point2 dest_offset = offset;
if (centered)
dest_offset -= frame_size / 2;
if (Engine::get_singleton()->get_use_gpu_pixel_snap()) {
dest_offset = dest_offset.floor();
}
_cached_dst_rect = Rect2(dest_offset, frame_size);
}
void BulletManagerBulletType::_shape_changed() {
update();
}
void BulletManagerBulletType::_area_inout(int p_status, const RID &p_area, int p_instance, int p_area_shape, int p_self_shape) {
ERR_FAIL_COND(p_self_shape >= _shapes.size());
Object *collider = ObjectDB::get_instance(p_instance);
int bullet_id = _shapes[p_self_shape];
if (bullet_id != -1 && _bullet_manager->is_bullet_active(bullet_id)) {
emit_signal("area_entered_bullet", bullet_id, collider);
}
}
void BulletManagerBulletType::_body_inout(int p_status, const RID &p_body, int p_instance, int p_body_shape, int p_area_shape) {
ERR_FAIL_COND(p_area_shape >= _shapes.size());
Object *collider = ObjectDB::get_instance(p_instance);
int bullet_id = _shapes[p_area_shape];
if (bullet_id != -1 && _bullet_manager->is_bullet_active(bullet_id)) {
emit_signal("body_entered_bullet", bullet_id, collider);
}
}
int BulletManagerBulletType::add_shape(int bullet_idx, Transform2D transform) {
if (_unused_shapes.size() == 0) {
Physics2DServer::get_singleton()->area_add_shape(area, collision_shape->get_rid(), transform);
_shapes.push_back(bullet_idx);
return _shapes.size() - 1;
} else {
int shape_idx = _unused_shapes.front()->get();
_unused_shapes.pop_front();
Physics2DServer::get_singleton()->area_set_shape_transform(area, shape_idx, transform);
Physics2DServer::get_singleton()->area_set_shape_disabled(area, shape_idx, false);
_shapes.set(shape_idx, bullet_idx);
return shape_idx;
}
}
void BulletManagerBulletType::remove_shape(int shape_idx) {
if (shape_idx >= _shapes.size() || shape_idx < 0) {
return;
}
Physics2DServer::get_singleton()->area_set_shape_disabled(area, shape_idx, true);
_shapes.set(shape_idx, -1);
_unused_shapes.push_back(shape_idx);
}
void BulletManagerBulletType::custom_update() {
if (!has_custom_update) {
return;
}
Array indices;
for (int i = 0; i < _shapes.size(); i++) {
if (_shapes[i] != -1) {
indices.push_back(_shapes[i]);
}
}
get_script_instance()->call("_update", indices);
}
int BulletManagerBulletType::get_bullet_id(int shape_index) {
if (shape_index < _shapes.size())
return _shapes[shape_index];
return -1;
}
void BulletManagerBulletType::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_PARENTED: {
_bullet_manager = cast_to<BulletManager>(get_parent());
if (!_bullet_manager) {
return;
}
_bullet_manager->register_bullet_type(this);
} break;
case NOTIFICATION_UNPARENTED: {
if (!_bullet_manager) {
return;
}
_bullet_manager->unregister_bullet_type(this);
_bullet_manager = NULL;
_shapes.clear();
_unused_shapes.clear();
} break;
case NOTIFICATION_DRAW: {
if (!Engine::get_singleton()->is_editor_hint()) {
return;
}
if (texture != NULL) {
_update_cached_rects();
texture->draw_rect_region(get_canvas_item(), _cached_dst_rect, _cached_src_rect, Color(1, 1, 1), false);
}
if (collision_shape != NULL && collision_shape.is_valid()) {
collision_shape->draw(get_canvas_item(), get_tree()->get_debug_collisions_color());
}
} break;
case NOTIFICATION_ENTER_TREE: {
if (!Engine::get_singleton()->is_editor_hint()) {
set_transform(Transform2D()); //don't want bullets to be drawn at an offset
}
Physics2DServer *ps = Physics2DServer::get_singleton();
ps->area_set_space(area, get_world_2d()->get_space());
ps->area_set_transform(area, Transform2D());
ps->area_set_collision_layer(area, collision_layer);
ps->area_set_collision_mask(area, collision_mask);
} break;
case NOTIFICATION_EXIT_TREE: {
Physics2DServer::get_singleton()->area_set_space(area, RID());
} break;
case NOTIFICATION_READY: {
if (get_script_instance() && get_script_instance()->has_method("_update")) {
print_line("has_custom_update");
has_custom_update = true;
}
} break;
}
}
void BulletManagerBulletType::_bind_methods() {
//VISUAL
ClassDB::bind_method(D_METHOD("set_texture", "texture"), &BulletManagerBulletType::set_texture);
ClassDB::bind_method(D_METHOD("get_texture"), &BulletManagerBulletType::get_texture);
ClassDB::bind_method(D_METHOD("set_normal_map", "normal_map"), &BulletManagerBulletType::set_normal_map);
ClassDB::bind_method(D_METHOD("get_normal_map"), &BulletManagerBulletType::get_normal_map);
ClassDB::bind_method(D_METHOD("set_vframes", "vframes"), &BulletManagerBulletType::set_vframes);
ClassDB::bind_method(D_METHOD("get_vframes"), &BulletManagerBulletType::get_vframes);
ClassDB::bind_method(D_METHOD("set_hframes", "hframes"), &BulletManagerBulletType::set_hframes);
ClassDB::bind_method(D_METHOD("get_hframes"), &BulletManagerBulletType::get_hframes);
ClassDB::bind_method(D_METHOD("set_frame", "frame"), &BulletManagerBulletType::set_frame);
ClassDB::bind_method(D_METHOD("get_frame"), &BulletManagerBulletType::get_frame);
ClassDB::bind_method(D_METHOD("set_centered", "centered"), &BulletManagerBulletType::set_centered);
ClassDB::bind_method(D_METHOD("is_centered"), &BulletManagerBulletType::is_centered);
ClassDB::bind_method(D_METHOD("set_offset", "offset"), &BulletManagerBulletType::set_offset);
ClassDB::bind_method(D_METHOD("get_offset"), &BulletManagerBulletType::get_offset);
ClassDB::bind_method(D_METHOD("set_region", "enabled"), &BulletManagerBulletType::set_region);
ClassDB::bind_method(D_METHOD("is_region"), &BulletManagerBulletType::is_region);
ClassDB::bind_method(D_METHOD("set_region_rect", "rect"), &BulletManagerBulletType::set_region_rect);
ClassDB::bind_method(D_METHOD("get_region_rect"), &BulletManagerBulletType::get_region_rect);
ClassDB::bind_method(D_METHOD("set_rotate_visual", "enabled"), &BulletManagerBulletType::set_rotate_visual);
ClassDB::bind_method(D_METHOD("is_rotating_visual"), &BulletManagerBulletType::is_rotating_visual);
//PHYSICS
ClassDB::bind_method(D_METHOD("_body_inout"), &BulletManagerBulletType::_body_inout);
ClassDB::bind_method(D_METHOD("_area_inout"), &BulletManagerBulletType::_area_inout);
ClassDB::bind_method(D_METHOD("_shape_changed"), &BulletManagerBulletType::_shape_changed);
ClassDB::bind_method(D_METHOD("set_collision_shape", "collision_shape"), &BulletManagerBulletType::set_collision_shape);
ClassDB::bind_method(D_METHOD("get_collision_shape"), &BulletManagerBulletType::get_collision_shape);
ClassDB::bind_method(D_METHOD("set_collision_layer", "collision_layer"), &BulletManagerBulletType::set_collision_layer);
ClassDB::bind_method(D_METHOD("get_collision_layer"), &BulletManagerBulletType::get_collision_layer);
ClassDB::bind_method(D_METHOD("set_collision_mask", "collision_mask"), &BulletManagerBulletType::set_collision_mask);
ClassDB::bind_method(D_METHOD("get_collision_mask"), &BulletManagerBulletType::get_collision_mask);
ClassDB::bind_method(D_METHOD("set_rotate_physics", "enabled"), &BulletManagerBulletType::set_rotate_physics);
ClassDB::bind_method(D_METHOD("is_rotating_physics"), &BulletManagerBulletType::is_rotating_physics);
ClassDB::bind_method(D_METHOD("get_bullet_id", "shape_index"), &BulletManagerBulletType::get_bullet_id);
//VISUAL PROPERTIES
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "normal_map", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_normal_map", "get_normal_map");
ADD_GROUP("Offset", "");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "centered"), "set_centered", "is_centered");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "offset"), "set_offset", "get_offset");
ADD_GROUP("Animation", "");
ADD_PROPERTY(PropertyInfo(Variant::INT, "vframes", PROPERTY_HINT_RANGE, "1,16384,1"), "set_vframes", "get_vframes");
ADD_PROPERTY(PropertyInfo(Variant::INT, "hframes", PROPERTY_HINT_RANGE, "1,16384,1"), "set_hframes", "get_hframes");
ADD_PROPERTY(PropertyInfo(Variant::INT, "frame", PROPERTY_HINT_SPRITE_FRAME), "set_frame", "get_frame");
ADD_GROUP("Region", "region_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "region_enabled"), "set_region", "is_region");
ADD_PROPERTY(PropertyInfo(Variant::RECT2, "region_rect"), "set_region_rect", "get_region_rect");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "rotate_visual"), "set_rotate_visual", "is_rotating_visual");
//PHYSICS PROPERTIES
ADD_GROUP("Collision", "collision_");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "collision_shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape2D"), "set_collision_shape", "get_collision_shape");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_layer", "get_collision_layer");
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_mask", "get_collision_mask");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "rotate_physics"), "set_rotate_physics", "is_rotating_physics");
ADD_SIGNAL(MethodInfo("area_entered_bullet", PropertyInfo(Variant::INT, "bullet_id", PROPERTY_HINT_NONE, "bullet_id"), PropertyInfo(Variant::OBJECT, "area", PROPERTY_HINT_RESOURCE_TYPE, "Area2D")));
ADD_SIGNAL(MethodInfo("body_entered_bullet", PropertyInfo(Variant::INT, "bullet_id", PROPERTY_HINT_NONE, "bullet_id"), PropertyInfo(Variant::OBJECT, "body", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsBody2D")));
ADD_SIGNAL(MethodInfo("bullet_clipped", PropertyInfo(Variant::INT, "bullet_id", PROPERTY_HINT_NONE, "bullet_id")));
}
BulletManagerBulletType::BulletManagerBulletType() {
Physics2DServer *ps = Physics2DServer::get_singleton();
area = ps->area_create();
ps->area_set_transform(area, Transform2D());
ps->area_attach_object_instance_id(area, get_instance_id());
ps->area_set_monitor_callback(area, this, _body_inout_name);
ps->area_set_area_monitor_callback(area, this, _area_inout_name);
}
BulletManagerBulletType::~BulletManagerBulletType() {
if (area.is_valid())
Physics2DServer::get_singleton()->free(area);
}
void BulletManager::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
} break;
case NOTIFICATION_READY: {
set_physics_process(true);
} break;
case NOTIFICATION_DRAW: {
if (Engine::get_singleton()->is_editor_hint()) {
return;
} else {
_draw_bullets();
}
} break;
case NOTIFICATION_PROCESS: {
} break;
case NOTIFICATION_PHYSICS_PROCESS: {
_update_bullets();
} break;
}
}
int BulletManager::add_bullet(StringName type_name, Vector2 position, real_t angle, real_t speed) {
// Physics2DServer *ps = Physics2DServer::get_singleton();
BulletManagerBulletType *type = types[type_name];
BulletManagerBullet *bullet;
if (_unused_ids.size() == 0) {
BulletManagerBullet new_bullet;
new_bullet.id = _bullets.size();
_bullets.push_back(new_bullet);
bullet = &_bullets.write[new_bullet.id];
} else {
int id = _unused_ids.front()->get();
_unused_ids.pop_front();
bullet = &_bullets.write[id];
}
ERR_FAIL_COND_V(_active_bullets.size() >= _bullets.size(), 0);
bullet->type = type;
bullet->set_angle(angle); //the set_angle function also rotates the matrix if rotate_physics is true for the bullet type.
bullet->speed = speed;
bullet->matrix.elements[2] = position;
bullet->is_queued_for_deletion = false;
bullet->shape_index = type->add_shape(bullet->id, bullet->matrix);
_active_bullets.push_back(bullet->id);
return bullet->id;
}
void BulletManager::clear() {
// Physics2DServer *ps = Physics2DServer::get_singleton();
List<int>::Element *E = _active_bullets.front();
while (E) {
_bullets.write[E->get()].is_queued_for_deletion = true;
E = E->next();
}
}
int BulletManager::count() {
return _active_bullets.size();
}
void BulletManager::set_bounds_margin(float p_bounds_margin) {
bounds_margin = p_bounds_margin;
}
float BulletManager::get_bounds_margin() const {
return bounds_margin;
}
void BulletManager::_draw_bullets() {
VisualServer *vs = VS::get_singleton();
//Update cached type info incase any of its properties have been changed.
for (Map<StringName, BulletManagerBulletType *>::Element *E = types.front(); E; E = E->next()) {
BulletManagerBulletType *type = E->get();
type->_update_cached_rects();
vs->canvas_item_clear(type->get_canvas_item());
}
if (_active_bullets.size() == 0) {
return;
}
List<int>::Element *E = _active_bullets.front();
//for(int i = 0; i < bullets.size(); i++) {
while (E) {
//Bullet* bullet = r[i];
BulletManagerBullet *bullet = &_bullets.write[E->get()];
BulletManagerBulletType *type = bullet->type;
RID ci = type->get_canvas_item();
if (type->rotate_visual) {
Transform2D tform;
tform.set_origin(bullet->matrix.get_origin());
tform.set_rotation_and_scale(bullet->direction.angle() + (Math_PI * -0.5), bullet->matrix.get_scale());
vs->canvas_item_add_set_transform(ci, tform);
//draw_set_transform(bullet->matrix.get_origin(), bullet->direction.angle() + (Math_PI * -0.5), bullet->matrix.get_scale());
} else {
vs->canvas_item_add_set_transform(ci, bullet->matrix);
//draw_set_transform_matrix(bullet->matrix);
}
vs->canvas_item_add_texture_rect_region(ci, type->_cached_dst_rect, type->texture->get_rid(), type->_cached_src_rect);
//type->collision_shape->draw(ci, get_tree()->get_debug_collisions_color());
//draw_texture_rect_region(type->texture, type->_cached_dst_rect, type->_cached_src_rect, Color(1, 1, 1), false, type->normal_map);
E = E->next();
}
}
void BulletManager::_update_bullets() {
Physics2DServer *ps = Physics2DServer::get_singleton();
float delta = get_physics_process_delta_time();
// int size = _active_bullets.size();
Rect2 visible_rect;
_get_visible_rect(visible_rect);
visible_rect = visible_rect.grow(bounds_margin);
for (int i = 0; i < _bullets.size(); i++) {
if (!_bullets[i].is_queued_for_deletion) {
_bullets.write[i].matrix[2] += _bullets[i].direction * _bullets[i].speed * delta;
if (!visible_rect.has_point(_bullets[i].matrix.get_origin())) {
_bullets.write[i].is_queued_for_deletion = true;
_bullets[i].type->emit_signal("bullet_clipped", _bullets[i].id);
}
}
}
List<int>::Element *E = _active_bullets.front();
while (E) {
int idx = E->get();
if (_bullets[idx].is_queued_for_deletion) {
_bullets[idx].type->remove_shape(_bullets[idx].shape_index);
_unused_ids.push_front(_bullets[idx].id);
E->erase();
} else {
//bullet->matrix[2] += bullet->direction * bullet->speed * delta;
ps->area_set_shape_transform(_bullets[idx].type->area, _bullets[idx].shape_index, _bullets[idx].matrix);
}
E = E->next();
}
Map<StringName, BulletManagerBulletType *>::Element *T = types.front();
while (T) {
BulletManagerBulletType *type = T->get();
if (type->has_custom_update) {
type->custom_update();
}
T = T->next();
}
update();
}
//Should only be used on direct children. BulletManagerBulletTypes will call this on themselves when parented to a BulletManager.
//Godot doesn't allow duplicate names among neighbors, so i won't check for duplicates here.
void BulletManager::register_bullet_type(BulletManagerBulletType *type) {
types[type->get_name()] = type;
}
void BulletManager::unregister_bullet_type(BulletManagerBulletType *type) {
clear_by_type(type);
types.erase(type->get_name());
}
void BulletManager::_get_visible_rect(Rect2 &rect) {
Transform2D ctrans = get_viewport()->get_canvas_transform();
rect.position = -ctrans.get_origin() / ctrans.get_scale();
rect.size = get_viewport_rect().size;
}
void BulletManager::set_bullet_position(int bullet_id, Vector2 position) {
if (bullet_id < _bullets.size()) {
_bullets.write[bullet_id].matrix.set_origin(position);
}
}
Vector2 BulletManager::get_bullet_position(int bullet_id) const {
if (bullet_id < _bullets.size()) {
return _bullets[bullet_id].matrix.get_origin();
}
return Vector2();
}
void BulletManager::set_bullet_speed(int bullet_id, real_t speed) {
if (bullet_id < _bullets.size()) {
_bullets.write[bullet_id].speed = speed;
}
}
real_t BulletManager::get_bullet_speed(int bullet_id) const {
if (bullet_id < _bullets.size()) {
return _bullets[bullet_id].speed;
}
return 0.0;
}
void BulletManager::set_bullet_angle(int bullet_id, real_t angle) {
if (bullet_id < _bullets.size()) {
_bullets.write[bullet_id].set_angle(angle);
}
}
real_t BulletManager::get_bullet_angle(int bullet_id) const {
if (bullet_id < _bullets.size()) {
return _bullets[bullet_id].direction.angle();
}
return 0.0;
}
void BulletManager::set_bullet_custom_data(int bullet_id, Variant custom_data) {
if (bullet_id < _bullets.size()) {
_bullets.write[bullet_id].custom_data = custom_data;
}
}
Variant BulletManager::get_bullet_custom_data(int bullet_id) const {
if (bullet_id < _bullets.size()) {
return _bullets[bullet_id].custom_data;
}
return false;
}
void BulletManager::queue_delete_bullet(int bullet_id) {
if (bullet_id < _bullets.size()) {
_bullets.write[bullet_id].is_queued_for_deletion = true;
}
}
bool BulletManager::is_bullet_active(int bullet_id) const {
if (bullet_id < _bullets.size()) {
return !_bullets[bullet_id].is_queued_for_deletion;
}
return false;
}
void BulletManager::clear_by_type(BulletManagerBulletType *type) {
for (int i = 0; i < _bullets.size(); i++) {
if (_bullets[i].type == type)
_bullets.write[i].is_queued_for_deletion = true;
}
}
void BulletManager::_clear_by_type_script(Object *type) {
BulletManagerBulletType *castedType = cast_to<BulletManagerBulletType>(type);
if (!castedType)
return;
clear_by_type(castedType);
}
void BulletManager::clear_by_mask(int mask) {
for (int i = 0; i < _bullets.size(); i++) {
if ((_bullets[i].type->collision_mask & mask) > 0)
_bullets.write[i].is_queued_for_deletion = true;
}
}
void BulletManager::clear_by_layer(int layer) {
for (int i = 0; i < _bullets.size(); i++) {
if ((_bullets[i].type->collision_mask & layer) > 0)
_bullets.write[i].is_queued_for_deletion = true;
}
}
void BulletManager::_bind_methods() {
ClassDB::bind_method(D_METHOD("add_bullet", "position", "angle", "speed"), &BulletManager::add_bullet);
ClassDB::bind_method(D_METHOD("set_bullet_position", "bullet_id", "position"), &BulletManager::set_bullet_position);
ClassDB::bind_method(D_METHOD("get_bullet_position", "bullet_id"), &BulletManager::get_bullet_position);
ClassDB::bind_method(D_METHOD("set_bullet_speed", "bullet_id", "speed"), &BulletManager::set_bullet_speed);
ClassDB::bind_method(D_METHOD("get_bullet_speed", "bullet_id"), &BulletManager::get_bullet_speed);
ClassDB::bind_method(D_METHOD("set_bullet_angle", "bullet_id", "angle"), &BulletManager::set_bullet_angle);
ClassDB::bind_method(D_METHOD("get_bullet_angle", "bullet_id"), &BulletManager::get_bullet_angle);
ClassDB::bind_method(D_METHOD("set_bullet_custom_data", "bullet_id", "variant"), &BulletManager::set_bullet_custom_data);
ClassDB::bind_method(D_METHOD("get_bullet_custom_data", "bullet_id"), &BulletManager::get_bullet_custom_data);
ClassDB::bind_method(D_METHOD("queue_delete_bullet", "bullet_id"), &BulletManager::queue_delete_bullet);
ClassDB::bind_method(D_METHOD("clear"), &BulletManager::clear);
ClassDB::bind_method(D_METHOD("_clear_by_type_script", "type"), &BulletManager::_clear_by_type_script);
ClassDB::bind_method(D_METHOD("clear_by_mask", "mask"), &BulletManager::clear_by_mask);
ClassDB::bind_method(D_METHOD("clear_by_layer", "layer"), &BulletManager::clear_by_layer);
ClassDB::bind_method(D_METHOD("set_bounds_margin", "bounds_margin"), &BulletManager::set_bounds_margin);
ClassDB::bind_method(D_METHOD("get_bounds_margin"), &BulletManager::get_bounds_margin);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounds_margin", PROPERTY_HINT_NONE), "set_bounds_margin", "get_bounds_margin");
}
| 36.978495 | 206 | 0.732262 | ppiecuch |
7929408cad294d525e406b370f262c31ad530f88 | 110,677 | cpp | C++ | src/data/wordlists/spanish.cpp | xdvio/native-bip39 | feedd8201688e9996113b7d7f10017d3a705b31f | [
"MIT"
] | 1 | 2021-03-31T14:01:41.000Z | 2021-03-31T14:01:41.000Z | src/data/wordlists/spanish.cpp | xdvio/native-bip39 | feedd8201688e9996113b7d7f10017d3a705b31f | [
"MIT"
] | null | null | null | src/data/wordlists/spanish.cpp | xdvio/native-bip39 | feedd8201688e9996113b7d7f10017d3a705b31f | [
"MIT"
] | 2 | 2019-09-28T06:53:58.000Z | 2020-07-07T16:46:31.000Z | /* Generated file - do not edit! */
#include "minter/bip39/wordlist.h"
static const unsigned char es_[] = {
0x61, 0xcc, 0x81, 0x62, 0x61, 0x63, 0x6f, 0,
0x61, 0x62, 0x64, 0x6f, 0x6d, 0x65, 0x6e, 0,
0x61, 0x62, 0x65, 0x6a, 0x61, 0,
0x61, 0x62, 0x69, 0x65, 0x72, 0x74, 0x6f, 0,
0x61, 0x62, 0x6f, 0x67, 0x61, 0x64, 0x6f, 0,
0x61, 0x62, 0x6f, 0x6e, 0x6f, 0,
0x61, 0x62, 0x6f, 0x72, 0x74, 0x6f, 0,
0x61, 0x62, 0x72, 0x61, 0x7a, 0x6f, 0,
0x61, 0x62, 0x72, 0x69, 0x72, 0,
0x61, 0x62, 0x75, 0x65, 0x6c, 0x6f, 0,
0x61, 0x62, 0x75, 0x73, 0x6f, 0,
0x61, 0x63, 0x61, 0x62, 0x61, 0x72, 0,
0x61, 0x63, 0x61, 0x64, 0x65, 0x6d, 0x69, 0x61, 0,
0x61, 0x63, 0x63, 0x65, 0x73, 0x6f, 0,
0x61, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x61, 0x63, 0x65, 0x69, 0x74, 0x65, 0,
0x61, 0x63, 0x65, 0x6c, 0x67, 0x61, 0,
0x61, 0x63, 0x65, 0x6e, 0x74, 0x6f, 0,
0x61, 0x63, 0x65, 0x70, 0x74, 0x61, 0x72, 0,
0x61, 0xcc, 0x81, 0x63, 0x69, 0x64, 0x6f, 0,
0x61, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x72, 0,
0x61, 0x63, 0x6e, 0x65, 0xcc, 0x81, 0,
0x61, 0x63, 0x6f, 0x67, 0x65, 0x72, 0,
0x61, 0x63, 0x6f, 0x73, 0x6f, 0,
0x61, 0x63, 0x74, 0x69, 0x76, 0x6f, 0,
0x61, 0x63, 0x74, 0x6f, 0,
0x61, 0x63, 0x74, 0x72, 0x69, 0x7a, 0,
0x61, 0x63, 0x74, 0x75, 0x61, 0x72, 0,
0x61, 0x63, 0x75, 0x64, 0x69, 0x72, 0,
0x61, 0x63, 0x75, 0x65, 0x72, 0x64, 0x6f, 0,
0x61, 0x63, 0x75, 0x73, 0x61, 0x72, 0,
0x61, 0x64, 0x69, 0x63, 0x74, 0x6f, 0,
0x61, 0x64, 0x6d, 0x69, 0x74, 0x69, 0x72, 0,
0x61, 0x64, 0x6f, 0x70, 0x74, 0x61, 0x72, 0,
0x61, 0x64, 0x6f, 0x72, 0x6e, 0x6f, 0,
0x61, 0x64, 0x75, 0x61, 0x6e, 0x61, 0,
0x61, 0x64, 0x75, 0x6c, 0x74, 0x6f, 0,
0x61, 0x65, 0xcc, 0x81, 0x72, 0x65, 0x6f, 0,
0x61, 0x66, 0x65, 0x63, 0x74, 0x61, 0x72, 0,
0x61, 0x66, 0x69, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x61, 0x66, 0x69, 0x6e, 0x61, 0x72, 0,
0x61, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x72, 0,
0x61, 0xcc, 0x81, 0x67, 0x69, 0x6c, 0,
0x61, 0x67, 0x69, 0x74, 0x61, 0x72, 0,
0x61, 0x67, 0x6f, 0x6e, 0x69, 0xcc, 0x81, 0x61, 0,
0x61, 0x67, 0x6f, 0x73, 0x74, 0x6f, 0,
0x61, 0x67, 0x6f, 0x74, 0x61, 0x72, 0,
0x61, 0x67, 0x72, 0x65, 0x67, 0x61, 0x72, 0,
0x61, 0x67, 0x72, 0x69, 0x6f, 0,
0x61, 0x67, 0x75, 0x61, 0,
0x61, 0x67, 0x75, 0x64, 0x6f, 0,
0x61, 0xcc, 0x81, 0x67, 0x75, 0x69, 0x6c, 0x61, 0,
0x61, 0x67, 0x75, 0x6a, 0x61, 0,
0x61, 0x68, 0x6f, 0x67, 0x6f, 0,
0x61, 0x68, 0x6f, 0x72, 0x72, 0x6f, 0,
0x61, 0x69, 0x72, 0x65, 0,
0x61, 0x69, 0x73, 0x6c, 0x61, 0x72, 0,
0x61, 0x6a, 0x65, 0x64, 0x72, 0x65, 0x7a, 0,
0x61, 0x6a, 0x65, 0x6e, 0x6f, 0,
0x61, 0x6a, 0x75, 0x73, 0x74, 0x65, 0,
0x61, 0x6c, 0x61, 0x63, 0x72, 0x61, 0xcc, 0x81, 0x6e, 0,
0x61, 0x6c, 0x61, 0x6d, 0x62, 0x72, 0x65, 0,
0x61, 0x6c, 0x61, 0x72, 0x6d, 0x61, 0,
0x61, 0x6c, 0x62, 0x61, 0,
0x61, 0xcc, 0x81, 0x6c, 0x62, 0x75, 0x6d, 0,
0x61, 0x6c, 0x63, 0x61, 0x6c, 0x64, 0x65, 0,
0x61, 0x6c, 0x64, 0x65, 0x61, 0,
0x61, 0x6c, 0x65, 0x67, 0x72, 0x65, 0,
0x61, 0x6c, 0x65, 0x6a, 0x61, 0x72, 0,
0x61, 0x6c, 0x65, 0x72, 0x74, 0x61, 0,
0x61, 0x6c, 0x65, 0x74, 0x61, 0,
0x61, 0x6c, 0x66, 0x69, 0x6c, 0x65, 0x72, 0,
0x61, 0x6c, 0x67, 0x61, 0,
0x61, 0x6c, 0x67, 0x6f, 0x64, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x61, 0x6c, 0x69, 0x61, 0x64, 0x6f, 0,
0x61, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0,
0x61, 0x6c, 0x69, 0x76, 0x69, 0x6f, 0,
0x61, 0x6c, 0x6d, 0x61, 0,
0x61, 0x6c, 0x6d, 0x65, 0x6a, 0x61, 0,
0x61, 0x6c, 0x6d, 0x69, 0xcc, 0x81, 0x62, 0x61, 0x72, 0,
0x61, 0x6c, 0x74, 0x61, 0x72, 0,
0x61, 0x6c, 0x74, 0x65, 0x7a, 0x61, 0,
0x61, 0x6c, 0x74, 0x69, 0x76, 0x6f, 0,
0x61, 0x6c, 0x74, 0x6f, 0,
0x61, 0x6c, 0x74, 0x75, 0x72, 0x61, 0,
0x61, 0x6c, 0x75, 0x6d, 0x6e, 0x6f, 0,
0x61, 0x6c, 0x7a, 0x61, 0x72, 0,
0x61, 0x6d, 0x61, 0x62, 0x6c, 0x65, 0,
0x61, 0x6d, 0x61, 0x6e, 0x74, 0x65, 0,
0x61, 0x6d, 0x61, 0x70, 0x6f, 0x6c, 0x61, 0,
0x61, 0x6d, 0x61, 0x72, 0x67, 0x6f, 0,
0x61, 0x6d, 0x61, 0x73, 0x61, 0x72, 0,
0x61, 0xcc, 0x81, 0x6d, 0x62, 0x61, 0x72, 0,
0x61, 0xcc, 0x81, 0x6d, 0x62, 0x69, 0x74, 0x6f, 0,
0x61, 0x6d, 0x65, 0x6e, 0x6f, 0,
0x61, 0x6d, 0x69, 0x67, 0x6f, 0,
0x61, 0x6d, 0x69, 0x73, 0x74, 0x61, 0x64, 0,
0x61, 0x6d, 0x6f, 0x72, 0,
0x61, 0x6d, 0x70, 0x61, 0x72, 0x6f, 0,
0x61, 0x6d, 0x70, 0x6c, 0x69, 0x6f, 0,
0x61, 0x6e, 0x63, 0x68, 0x6f, 0,
0x61, 0x6e, 0x63, 0x69, 0x61, 0x6e, 0x6f, 0,
0x61, 0x6e, 0x63, 0x6c, 0x61, 0,
0x61, 0x6e, 0x64, 0x61, 0x72, 0,
0x61, 0x6e, 0x64, 0x65, 0xcc, 0x81, 0x6e, 0,
0x61, 0x6e, 0x65, 0x6d, 0x69, 0x61, 0,
0x61, 0xcc, 0x81, 0x6e, 0x67, 0x75, 0x6c, 0x6f, 0,
0x61, 0x6e, 0x69, 0x6c, 0x6c, 0x6f, 0,
0x61, 0xcc, 0x81, 0x6e, 0x69, 0x6d, 0x6f, 0,
0x61, 0x6e, 0x69, 0xcc, 0x81, 0x73, 0,
0x61, 0x6e, 0x6f, 0x74, 0x61, 0x72, 0,
0x61, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0,
0x61, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x6f, 0,
0x61, 0x6e, 0x74, 0x6f, 0x6a, 0x6f, 0,
0x61, 0x6e, 0x75, 0x61, 0x6c, 0,
0x61, 0x6e, 0x75, 0x6c, 0x61, 0x72, 0,
0x61, 0x6e, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0,
0x61, 0x6e, 0xcc, 0x83, 0x61, 0x64, 0x69, 0x72, 0,
0x61, 0x6e, 0xcc, 0x83, 0x65, 0x6a, 0x6f, 0,
0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x61, 0x70, 0x61, 0x67, 0x61, 0x72, 0,
0x61, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0,
0x61, 0x70, 0x65, 0x74, 0x69, 0x74, 0x6f, 0,
0x61, 0x70, 0x69, 0x6f, 0,
0x61, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x72, 0,
0x61, 0x70, 0x6f, 0x64, 0x6f, 0,
0x61, 0x70, 0x6f, 0x72, 0x74, 0x65, 0,
0x61, 0x70, 0x6f, 0x79, 0x6f, 0,
0x61, 0x70, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0,
0x61, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x72, 0,
0x61, 0x70, 0x75, 0x65, 0x73, 0x74, 0x61, 0,
0x61, 0x70, 0x75, 0x72, 0x6f, 0,
0x61, 0x72, 0x61, 0x64, 0x6f, 0,
0x61, 0x72, 0x61, 0x6e, 0xcc, 0x83, 0x61, 0,
0x61, 0x72, 0x61, 0x72, 0,
0x61, 0xcc, 0x81, 0x72, 0x62, 0x69, 0x74, 0x72, 0x6f, 0,
0x61, 0xcc, 0x81, 0x72, 0x62, 0x6f, 0x6c, 0,
0x61, 0x72, 0x62, 0x75, 0x73, 0x74, 0x6f, 0,
0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x6f, 0,
0x61, 0x72, 0x63, 0x6f, 0,
0x61, 0x72, 0x64, 0x65, 0x72, 0,
0x61, 0x72, 0x64, 0x69, 0x6c, 0x6c, 0x61, 0,
0x61, 0x72, 0x64, 0x75, 0x6f, 0,
0x61, 0xcc, 0x81, 0x72, 0x65, 0x61, 0,
0x61, 0xcc, 0x81, 0x72, 0x69, 0x64, 0x6f, 0,
0x61, 0x72, 0x69, 0x65, 0x73, 0,
0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x69, 0xcc, 0x81, 0x61, 0,
0x61, 0x72, 0x6e, 0x65, 0xcc, 0x81, 0x73, 0,
0x61, 0x72, 0x6f, 0x6d, 0x61, 0,
0x61, 0x72, 0x70, 0x61, 0,
0x61, 0x72, 0x70, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x61, 0x72, 0x72, 0x65, 0x67, 0x6c, 0x6f, 0,
0x61, 0x72, 0x72, 0x6f, 0x7a, 0,
0x61, 0x72, 0x72, 0x75, 0x67, 0x61, 0,
0x61, 0x72, 0x74, 0x65, 0,
0x61, 0x72, 0x74, 0x69, 0x73, 0x74, 0x61, 0,
0x61, 0x73, 0x61, 0,
0x61, 0x73, 0x61, 0x64, 0x6f, 0,
0x61, 0x73, 0x61, 0x6c, 0x74, 0x6f, 0,
0x61, 0x73, 0x63, 0x65, 0x6e, 0x73, 0x6f, 0,
0x61, 0x73, 0x65, 0x67, 0x75, 0x72, 0x61, 0x72, 0,
0x61, 0x73, 0x65, 0x6f, 0,
0x61, 0x73, 0x65, 0x73, 0x6f, 0x72, 0,
0x61, 0x73, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0,
0x61, 0x73, 0x69, 0x6c, 0x6f, 0,
0x61, 0x73, 0x69, 0x73, 0x74, 0x69, 0x72, 0,
0x61, 0x73, 0x6e, 0x6f, 0,
0x61, 0x73, 0x6f, 0x6d, 0x62, 0x72, 0x6f, 0,
0x61, 0xcc, 0x81, 0x73, 0x70, 0x65, 0x72, 0x6f, 0,
0x61, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x61, 0,
0x61, 0x73, 0x74, 0x72, 0x6f, 0,
0x61, 0x73, 0x74, 0x75, 0x74, 0x6f, 0,
0x61, 0x73, 0x75, 0x6d, 0x69, 0x72, 0,
0x61, 0x73, 0x75, 0x6e, 0x74, 0x6f, 0,
0x61, 0x74, 0x61, 0x6a, 0x6f, 0,
0x61, 0x74, 0x61, 0x71, 0x75, 0x65, 0,
0x61, 0x74, 0x61, 0x72, 0,
0x61, 0x74, 0x65, 0x6e, 0x74, 0x6f, 0,
0x61, 0x74, 0x65, 0x6f, 0,
0x61, 0xcc, 0x81, 0x74, 0x69, 0x63, 0x6f, 0,
0x61, 0x74, 0x6c, 0x65, 0x74, 0x61, 0,
0x61, 0xcc, 0x81, 0x74, 0x6f, 0x6d, 0x6f, 0,
0x61, 0x74, 0x72, 0x61, 0x65, 0x72, 0,
0x61, 0x74, 0x72, 0x6f, 0x7a, 0,
0x61, 0x74, 0x75, 0xcc, 0x81, 0x6e, 0,
0x61, 0x75, 0x64, 0x61, 0x7a, 0,
0x61, 0x75, 0x64, 0x69, 0x6f, 0,
0x61, 0x75, 0x67, 0x65, 0,
0x61, 0x75, 0x6c, 0x61, 0,
0x61, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0,
0x61, 0x75, 0x73, 0x65, 0x6e, 0x74, 0x65, 0,
0x61, 0x75, 0x74, 0x6f, 0x72, 0,
0x61, 0x76, 0x61, 0x6c, 0,
0x61, 0x76, 0x61, 0x6e, 0x63, 0x65, 0,
0x61, 0x76, 0x61, 0x72, 0x6f, 0,
0x61, 0x76, 0x65, 0,
0x61, 0x76, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x61, 0,
0x61, 0x76, 0x65, 0x6e, 0x61, 0,
0x61, 0x76, 0x65, 0x73, 0x74, 0x72, 0x75, 0x7a, 0,
0x61, 0x76, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x61, 0x76, 0x69, 0x73, 0x6f, 0,
0x61, 0x79, 0x65, 0x72, 0,
0x61, 0x79, 0x75, 0x64, 0x61, 0,
0x61, 0x79, 0x75, 0x6e, 0x6f, 0,
0x61, 0x7a, 0x61, 0x66, 0x72, 0x61, 0xcc, 0x81, 0x6e, 0,
0x61, 0x7a, 0x61, 0x72, 0,
0x61, 0x7a, 0x6f, 0x74, 0x65, 0,
0x61, 0x7a, 0x75, 0xcc, 0x81, 0x63, 0x61, 0x72, 0,
0x61, 0x7a, 0x75, 0x66, 0x72, 0x65, 0,
0x61, 0x7a, 0x75, 0x6c, 0,
0x62, 0x61, 0x62, 0x61, 0,
0x62, 0x61, 0x62, 0x6f, 0x72, 0,
0x62, 0x61, 0x63, 0x68, 0x65, 0,
0x62, 0x61, 0x68, 0x69, 0xcc, 0x81, 0x61, 0,
0x62, 0x61, 0x69, 0x6c, 0x65, 0,
0x62, 0x61, 0x6a, 0x61, 0x72, 0,
0x62, 0x61, 0x6c, 0x61, 0x6e, 0x7a, 0x61, 0,
0x62, 0x61, 0x6c, 0x63, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x62, 0x61, 0x6c, 0x64, 0x65, 0,
0x62, 0x61, 0x6d, 0x62, 0x75, 0xcc, 0x81, 0,
0x62, 0x61, 0x6e, 0x63, 0x6f, 0,
0x62, 0x61, 0x6e, 0x64, 0x61, 0,
0x62, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x62, 0x61, 0x72, 0x62, 0x61, 0,
0x62, 0x61, 0x72, 0x63, 0x6f, 0,
0x62, 0x61, 0x72, 0x6e, 0x69, 0x7a, 0,
0x62, 0x61, 0x72, 0x72, 0x6f, 0,
0x62, 0x61, 0xcc, 0x81, 0x73, 0x63, 0x75, 0x6c, 0x61, 0,
0x62, 0x61, 0x73, 0x74, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x62, 0x61, 0x73, 0x75, 0x72, 0x61, 0,
0x62, 0x61, 0x74, 0x61, 0x6c, 0x6c, 0x61, 0,
0x62, 0x61, 0x74, 0x65, 0x72, 0x69, 0xcc, 0x81, 0x61, 0,
0x62, 0x61, 0x74, 0x69, 0x72, 0,
0x62, 0x61, 0x74, 0x75, 0x74, 0x61, 0,
0x62, 0x61, 0x75, 0xcc, 0x81, 0x6c, 0,
0x62, 0x61, 0x7a, 0x61, 0x72, 0,
0x62, 0x65, 0x62, 0x65, 0xcc, 0x81, 0,
0x62, 0x65, 0x62, 0x69, 0x64, 0x61, 0,
0x62, 0x65, 0x6c, 0x6c, 0x6f, 0,
0x62, 0x65, 0x73, 0x61, 0x72, 0,
0x62, 0x65, 0x73, 0x6f, 0,
0x62, 0x65, 0x73, 0x74, 0x69, 0x61, 0,
0x62, 0x69, 0x63, 0x68, 0x6f, 0,
0x62, 0x69, 0x65, 0x6e, 0,
0x62, 0x69, 0x6e, 0x67, 0x6f, 0,
0x62, 0x6c, 0x61, 0x6e, 0x63, 0x6f, 0,
0x62, 0x6c, 0x6f, 0x71, 0x75, 0x65, 0,
0x62, 0x6c, 0x75, 0x73, 0x61, 0,
0x62, 0x6f, 0x61, 0,
0x62, 0x6f, 0x62, 0x69, 0x6e, 0x61, 0,
0x62, 0x6f, 0x62, 0x6f, 0,
0x62, 0x6f, 0x63, 0x61, 0,
0x62, 0x6f, 0x63, 0x69, 0x6e, 0x61, 0,
0x62, 0x6f, 0x64, 0x61, 0,
0x62, 0x6f, 0x64, 0x65, 0x67, 0x61, 0,
0x62, 0x6f, 0x69, 0x6e, 0x61, 0,
0x62, 0x6f, 0x6c, 0x61, 0,
0x62, 0x6f, 0x6c, 0x65, 0x72, 0x6f, 0,
0x62, 0x6f, 0x6c, 0x73, 0x61, 0,
0x62, 0x6f, 0x6d, 0x62, 0x61, 0,
0x62, 0x6f, 0x6e, 0x64, 0x61, 0x64, 0,
0x62, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0,
0x62, 0x6f, 0x6e, 0x6f, 0,
0x62, 0x6f, 0x6e, 0x73, 0x61, 0xcc, 0x81, 0x69, 0,
0x62, 0x6f, 0x72, 0x64, 0x65, 0,
0x62, 0x6f, 0x72, 0x72, 0x61, 0x72, 0,
0x62, 0x6f, 0x73, 0x71, 0x75, 0x65, 0,
0x62, 0x6f, 0x74, 0x65, 0,
0x62, 0x6f, 0x74, 0x69, 0xcc, 0x81, 0x6e, 0,
0x62, 0x6f, 0xcc, 0x81, 0x76, 0x65, 0x64, 0x61, 0,
0x62, 0x6f, 0x7a, 0x61, 0x6c, 0,
0x62, 0x72, 0x61, 0x76, 0x6f, 0,
0x62, 0x72, 0x61, 0x7a, 0x6f, 0,
0x62, 0x72, 0x65, 0x63, 0x68, 0x61, 0,
0x62, 0x72, 0x65, 0x76, 0x65, 0,
0x62, 0x72, 0x69, 0x6c, 0x6c, 0x6f, 0,
0x62, 0x72, 0x69, 0x6e, 0x63, 0x6f, 0,
0x62, 0x72, 0x69, 0x73, 0x61, 0,
0x62, 0x72, 0x6f, 0x63, 0x61, 0,
0x62, 0x72, 0x6f, 0x6d, 0x61, 0,
0x62, 0x72, 0x6f, 0x6e, 0x63, 0x65, 0,
0x62, 0x72, 0x6f, 0x74, 0x65, 0,
0x62, 0x72, 0x75, 0x6a, 0x61, 0,
0x62, 0x72, 0x75, 0x73, 0x63, 0x6f, 0,
0x62, 0x72, 0x75, 0x74, 0x6f, 0,
0x62, 0x75, 0x63, 0x65, 0x6f, 0,
0x62, 0x75, 0x63, 0x6c, 0x65, 0,
0x62, 0x75, 0x65, 0x6e, 0x6f, 0,
0x62, 0x75, 0x65, 0x79, 0,
0x62, 0x75, 0x66, 0x61, 0x6e, 0x64, 0x61, 0,
0x62, 0x75, 0x66, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x62, 0x75, 0xcc, 0x81, 0x68, 0x6f, 0,
0x62, 0x75, 0x69, 0x74, 0x72, 0x65, 0,
0x62, 0x75, 0x6c, 0x74, 0x6f, 0,
0x62, 0x75, 0x72, 0x62, 0x75, 0x6a, 0x61, 0,
0x62, 0x75, 0x72, 0x6c, 0x61, 0,
0x62, 0x75, 0x72, 0x72, 0x6f, 0,
0x62, 0x75, 0x73, 0x63, 0x61, 0x72, 0,
0x62, 0x75, 0x74, 0x61, 0x63, 0x61, 0,
0x62, 0x75, 0x7a, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0x62, 0x61, 0x6c, 0x6c, 0x6f, 0,
0x63, 0x61, 0x62, 0x65, 0x7a, 0x61, 0,
0x63, 0x61, 0x62, 0x69, 0x6e, 0x61, 0,
0x63, 0x61, 0x62, 0x72, 0x61, 0,
0x63, 0x61, 0x63, 0x61, 0x6f, 0,
0x63, 0x61, 0x64, 0x61, 0xcc, 0x81, 0x76, 0x65, 0x72, 0,
0x63, 0x61, 0x64, 0x65, 0x6e, 0x61, 0,
0x63, 0x61, 0x65, 0x72, 0,
0x63, 0x61, 0x66, 0x65, 0xcc, 0x81, 0,
0x63, 0x61, 0x69, 0xcc, 0x81, 0x64, 0x61, 0,
0x63, 0x61, 0x69, 0x6d, 0x61, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0x6a, 0x61, 0,
0x63, 0x61, 0x6a, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0x6c, 0,
0x63, 0x61, 0x6c, 0x61, 0x6d, 0x61, 0x72, 0,
0x63, 0x61, 0x6c, 0x63, 0x69, 0x6f, 0,
0x63, 0x61, 0x6c, 0x64, 0x6f, 0,
0x63, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x64, 0,
0x63, 0x61, 0x6c, 0x6c, 0x65, 0,
0x63, 0x61, 0x6c, 0x6d, 0x61, 0,
0x63, 0x61, 0x6c, 0x6f, 0x72, 0,
0x63, 0x61, 0x6c, 0x76, 0x6f, 0,
0x63, 0x61, 0x6d, 0x61, 0,
0x63, 0x61, 0x6d, 0x62, 0x69, 0x6f, 0,
0x63, 0x61, 0x6d, 0x65, 0x6c, 0x6c, 0x6f, 0,
0x63, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0,
0x63, 0x61, 0x6d, 0x70, 0x6f, 0,
0x63, 0x61, 0xcc, 0x81, 0x6e, 0x63, 0x65, 0x72, 0,
0x63, 0x61, 0x6e, 0x64, 0x69, 0x6c, 0,
0x63, 0x61, 0x6e, 0x65, 0x6c, 0x61, 0,
0x63, 0x61, 0x6e, 0x67, 0x75, 0x72, 0x6f, 0,
0x63, 0x61, 0x6e, 0x69, 0x63, 0x61, 0,
0x63, 0x61, 0x6e, 0x74, 0x6f, 0,
0x63, 0x61, 0x6e, 0xcc, 0x83, 0x61, 0,
0x63, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0x6f, 0x62, 0x61, 0,
0x63, 0x61, 0x6f, 0x73, 0,
0x63, 0x61, 0x70, 0x61, 0x7a, 0,
0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0x70, 0x6f, 0x74, 0x65, 0,
0x63, 0x61, 0x70, 0x74, 0x61, 0x72, 0,
0x63, 0x61, 0x70, 0x75, 0x63, 0x68, 0x61, 0,
0x63, 0x61, 0x72, 0x61, 0,
0x63, 0x61, 0x72, 0x62, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x61, 0xcc, 0x81, 0x72, 0x63, 0x65, 0x6c, 0,
0x63, 0x61, 0x72, 0x65, 0x74, 0x61, 0,
0x63, 0x61, 0x72, 0x67, 0x61, 0,
0x63, 0x61, 0x72, 0x69, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x63, 0x61, 0x72, 0x6e, 0x65, 0,
0x63, 0x61, 0x72, 0x70, 0x65, 0x74, 0x61, 0,
0x63, 0x61, 0x72, 0x72, 0x6f, 0,
0x63, 0x61, 0x72, 0x74, 0x61, 0,
0x63, 0x61, 0x73, 0x61, 0,
0x63, 0x61, 0x73, 0x63, 0x6f, 0,
0x63, 0x61, 0x73, 0x65, 0x72, 0x6f, 0,
0x63, 0x61, 0x73, 0x70, 0x61, 0,
0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0,
0x63, 0x61, 0x74, 0x6f, 0x72, 0x63, 0x65, 0,
0x63, 0x61, 0x74, 0x72, 0x65, 0,
0x63, 0x61, 0x75, 0x64, 0x61, 0x6c, 0,
0x63, 0x61, 0x75, 0x73, 0x61, 0,
0x63, 0x61, 0x7a, 0x6f, 0,
0x63, 0x65, 0x62, 0x6f, 0x6c, 0x6c, 0x61, 0,
0x63, 0x65, 0x64, 0x65, 0x72, 0,
0x63, 0x65, 0x64, 0x72, 0x6f, 0,
0x63, 0x65, 0x6c, 0x64, 0x61, 0,
0x63, 0x65, 0xcc, 0x81, 0x6c, 0x65, 0x62, 0x72, 0x65, 0,
0x63, 0x65, 0x6c, 0x6f, 0x73, 0x6f, 0,
0x63, 0x65, 0xcc, 0x81, 0x6c, 0x75, 0x6c, 0x61, 0,
0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0,
0x63, 0x65, 0x6e, 0x69, 0x7a, 0x61, 0,
0x63, 0x65, 0x6e, 0x74, 0x72, 0x6f, 0,
0x63, 0x65, 0x72, 0x63, 0x61, 0,
0x63, 0x65, 0x72, 0x64, 0x6f, 0,
0x63, 0x65, 0x72, 0x65, 0x7a, 0x61, 0,
0x63, 0x65, 0x72, 0x6f, 0,
0x63, 0x65, 0x72, 0x72, 0x61, 0x72, 0,
0x63, 0x65, 0x72, 0x74, 0x65, 0x7a, 0x61, 0,
0x63, 0x65, 0xcc, 0x81, 0x73, 0x70, 0x65, 0x64, 0,
0x63, 0x65, 0x74, 0x72, 0x6f, 0,
0x63, 0x68, 0x61, 0x63, 0x61, 0x6c, 0,
0x63, 0x68, 0x61, 0x6c, 0x65, 0x63, 0x6f, 0,
0x63, 0x68, 0x61, 0x6d, 0x70, 0x75, 0xcc, 0x81, 0,
0x63, 0x68, 0x61, 0x6e, 0x63, 0x6c, 0x61, 0,
0x63, 0x68, 0x61, 0x70, 0x61, 0,
0x63, 0x68, 0x61, 0x72, 0x6c, 0x61, 0,
0x63, 0x68, 0x69, 0x63, 0x6f, 0,
0x63, 0x68, 0x69, 0x73, 0x74, 0x65, 0,
0x63, 0x68, 0x69, 0x76, 0x6f, 0,
0x63, 0x68, 0x6f, 0x71, 0x75, 0x65, 0,
0x63, 0x68, 0x6f, 0x7a, 0x61, 0,
0x63, 0x68, 0x75, 0x6c, 0x65, 0x74, 0x61, 0,
0x63, 0x68, 0x75, 0x70, 0x61, 0x72, 0,
0x63, 0x69, 0x63, 0x6c, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x69, 0x65, 0x67, 0x6f, 0,
0x63, 0x69, 0x65, 0x6c, 0x6f, 0,
0x63, 0x69, 0x65, 0x6e, 0,
0x63, 0x69, 0x65, 0x72, 0x74, 0x6f, 0,
0x63, 0x69, 0x66, 0x72, 0x61, 0,
0x63, 0x69, 0x67, 0x61, 0x72, 0x72, 0x6f, 0,
0x63, 0x69, 0x6d, 0x61, 0,
0x63, 0x69, 0x6e, 0x63, 0x6f, 0,
0x63, 0x69, 0x6e, 0x65, 0,
0x63, 0x69, 0x6e, 0x74, 0x61, 0,
0x63, 0x69, 0x70, 0x72, 0x65, 0xcc, 0x81, 0x73, 0,
0x63, 0x69, 0x72, 0x63, 0x6f, 0,
0x63, 0x69, 0x72, 0x75, 0x65, 0x6c, 0x61, 0,
0x63, 0x69, 0x73, 0x6e, 0x65, 0,
0x63, 0x69, 0x74, 0x61, 0,
0x63, 0x69, 0x75, 0x64, 0x61, 0x64, 0,
0x63, 0x6c, 0x61, 0x6d, 0x6f, 0x72, 0,
0x63, 0x6c, 0x61, 0x6e, 0,
0x63, 0x6c, 0x61, 0x72, 0x6f, 0,
0x63, 0x6c, 0x61, 0x73, 0x65, 0,
0x63, 0x6c, 0x61, 0x76, 0x65, 0,
0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x65, 0,
0x63, 0x6c, 0x69, 0x6d, 0x61, 0,
0x63, 0x6c, 0x69, 0xcc, 0x81, 0x6e, 0x69, 0x63, 0x61, 0,
0x63, 0x6f, 0x62, 0x72, 0x65, 0,
0x63, 0x6f, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x6f, 0x63, 0x68, 0x69, 0x6e, 0x6f, 0,
0x63, 0x6f, 0x63, 0x69, 0x6e, 0x61, 0,
0x63, 0x6f, 0x63, 0x6f, 0,
0x63, 0x6f, 0xcc, 0x81, 0x64, 0x69, 0x67, 0x6f, 0,
0x63, 0x6f, 0x64, 0x6f, 0,
0x63, 0x6f, 0x66, 0x72, 0x65, 0,
0x63, 0x6f, 0x67, 0x65, 0x72, 0,
0x63, 0x6f, 0x68, 0x65, 0x74, 0x65, 0,
0x63, 0x6f, 0x6a, 0x69, 0xcc, 0x81, 0x6e, 0,
0x63, 0x6f, 0x6a, 0x6f, 0,
0x63, 0x6f, 0x6c, 0x61, 0,
0x63, 0x6f, 0x6c, 0x63, 0x68, 0x61, 0,
0x63, 0x6f, 0x6c, 0x65, 0x67, 0x69, 0x6f, 0,
0x63, 0x6f, 0x6c, 0x67, 0x61, 0x72, 0,
0x63, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0,
0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x72, 0,
0x63, 0x6f, 0x6c, 0x6d, 0x6f, 0,
0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x61, 0,
0x63, 0x6f, 0x6d, 0x62, 0x61, 0x74, 0x65, 0,
0x63, 0x6f, 0x6d, 0x65, 0x72, 0,
0x63, 0x6f, 0x6d, 0x69, 0x64, 0x61, 0,
0x63, 0x6f, 0xcc, 0x81, 0x6d, 0x6f, 0x64, 0x6f, 0,
0x63, 0x6f, 0x6d, 0x70, 0x72, 0x61, 0,
0x63, 0x6f, 0x6e, 0x64, 0x65, 0,
0x63, 0x6f, 0x6e, 0x65, 0x6a, 0x6f, 0,
0x63, 0x6f, 0x6e, 0x67, 0x61, 0,
0x63, 0x6f, 0x6e, 0x6f, 0x63, 0x65, 0x72, 0,
0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6a, 0x6f, 0,
0x63, 0x6f, 0x6e, 0x74, 0x61, 0x72, 0,
0x63, 0x6f, 0x70, 0x61, 0,
0x63, 0x6f, 0x70, 0x69, 0x61, 0,
0x63, 0x6f, 0x72, 0x61, 0x7a, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x6f, 0x72, 0x62, 0x61, 0x74, 0x61, 0,
0x63, 0x6f, 0x72, 0x63, 0x68, 0x6f, 0,
0x63, 0x6f, 0x72, 0x64, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x6f, 0x72, 0x6f, 0x6e, 0x61, 0,
0x63, 0x6f, 0x72, 0x72, 0x65, 0x72, 0,
0x63, 0x6f, 0x73, 0x65, 0x72, 0,
0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0,
0x63, 0x6f, 0x73, 0x74, 0x61, 0,
0x63, 0x72, 0x61, 0xcc, 0x81, 0x6e, 0x65, 0x6f, 0,
0x63, 0x72, 0x61, 0xcc, 0x81, 0x74, 0x65, 0x72, 0,
0x63, 0x72, 0x65, 0x61, 0x72, 0,
0x63, 0x72, 0x65, 0x63, 0x65, 0x72, 0,
0x63, 0x72, 0x65, 0x69, 0xcc, 0x81, 0x64, 0x6f, 0,
0x63, 0x72, 0x65, 0x6d, 0x61, 0,
0x63, 0x72, 0x69, 0xcc, 0x81, 0x61, 0,
0x63, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0,
0x63, 0x72, 0x69, 0x70, 0x74, 0x61, 0,
0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0,
0x63, 0x72, 0x6f, 0x6d, 0x6f, 0,
0x63, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0x69, 0x63, 0x61, 0,
0x63, 0x72, 0x6f, 0x71, 0x75, 0x65, 0x74, 0x61, 0,
0x63, 0x72, 0x75, 0x64, 0x6f, 0,
0x63, 0x72, 0x75, 0x7a, 0,
0x63, 0x75, 0x61, 0x64, 0x72, 0x6f, 0,
0x63, 0x75, 0x61, 0x72, 0x74, 0x6f, 0,
0x63, 0x75, 0x61, 0x74, 0x72, 0x6f, 0,
0x63, 0x75, 0x62, 0x6f, 0,
0x63, 0x75, 0x62, 0x72, 0x69, 0x72, 0,
0x63, 0x75, 0x63, 0x68, 0x61, 0x72, 0x61, 0,
0x63, 0x75, 0x65, 0x6c, 0x6c, 0x6f, 0,
0x63, 0x75, 0x65, 0x6e, 0x74, 0x6f, 0,
0x63, 0x75, 0x65, 0x72, 0x64, 0x61, 0,
0x63, 0x75, 0x65, 0x73, 0x74, 0x61, 0,
0x63, 0x75, 0x65, 0x76, 0x61, 0,
0x63, 0x75, 0x69, 0x64, 0x61, 0x72, 0,
0x63, 0x75, 0x6c, 0x65, 0x62, 0x72, 0x61, 0,
0x63, 0x75, 0x6c, 0x70, 0x61, 0,
0x63, 0x75, 0x6c, 0x74, 0x6f, 0,
0x63, 0x75, 0x6d, 0x62, 0x72, 0x65, 0,
0x63, 0x75, 0x6d, 0x70, 0x6c, 0x69, 0x72, 0,
0x63, 0x75, 0x6e, 0x61, 0,
0x63, 0x75, 0x6e, 0x65, 0x74, 0x61, 0,
0x63, 0x75, 0x6f, 0x74, 0x61, 0,
0x63, 0x75, 0x70, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x63, 0x75, 0xcc, 0x81, 0x70, 0x75, 0x6c, 0x61, 0,
0x63, 0x75, 0x72, 0x61, 0x72, 0,
0x63, 0x75, 0x72, 0x69, 0x6f, 0x73, 0x6f, 0,
0x63, 0x75, 0x72, 0x73, 0x6f, 0,
0x63, 0x75, 0x72, 0x76, 0x61, 0,
0x63, 0x75, 0x74, 0x69, 0x73, 0,
0x64, 0x61, 0x6d, 0x61, 0,
0x64, 0x61, 0x6e, 0x7a, 0x61, 0,
0x64, 0x61, 0x72, 0,
0x64, 0x61, 0x72, 0x64, 0x6f, 0,
0x64, 0x61, 0xcc, 0x81, 0x74, 0x69, 0x6c, 0,
0x64, 0x65, 0x62, 0x65, 0x72, 0,
0x64, 0x65, 0xcc, 0x81, 0x62, 0x69, 0x6c, 0,
0x64, 0x65, 0xcc, 0x81, 0x63, 0x61, 0x64, 0x61, 0,
0x64, 0x65, 0x63, 0x69, 0x72, 0,
0x64, 0x65, 0x64, 0x6f, 0,
0x64, 0x65, 0x66, 0x65, 0x6e, 0x73, 0x61, 0,
0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x72, 0,
0x64, 0x65, 0x6a, 0x61, 0x72, 0,
0x64, 0x65, 0x6c, 0x66, 0x69, 0xcc, 0x81, 0x6e, 0,
0x64, 0x65, 0x6c, 0x67, 0x61, 0x64, 0x6f, 0,
0x64, 0x65, 0x6c, 0x69, 0x74, 0x6f, 0,
0x64, 0x65, 0x6d, 0x6f, 0x72, 0x61, 0,
0x64, 0x65, 0x6e, 0x73, 0x6f, 0,
0x64, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0,
0x64, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0,
0x64, 0x65, 0x72, 0x65, 0x63, 0x68, 0x6f, 0,
0x64, 0x65, 0x72, 0x72, 0x6f, 0x74, 0x61, 0,
0x64, 0x65, 0x73, 0x61, 0x79, 0x75, 0x6e, 0x6f, 0,
0x64, 0x65, 0x73, 0x65, 0x6f, 0,
0x64, 0x65, 0x73, 0x66, 0x69, 0x6c, 0x65, 0,
0x64, 0x65, 0x73, 0x6e, 0x75, 0x64, 0x6f, 0,
0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x6f, 0,
0x64, 0x65, 0x73, 0x76, 0x69, 0xcc, 0x81, 0x6f, 0,
0x64, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0,
0x64, 0x65, 0x74, 0x65, 0x6e, 0x65, 0x72, 0,
0x64, 0x65, 0x75, 0x64, 0x61, 0,
0x64, 0x69, 0xcc, 0x81, 0x61, 0,
0x64, 0x69, 0x61, 0x62, 0x6c, 0x6f, 0,
0x64, 0x69, 0x61, 0x64, 0x65, 0x6d, 0x61, 0,
0x64, 0x69, 0x61, 0x6d, 0x61, 0x6e, 0x74, 0x65, 0,
0x64, 0x69, 0x61, 0x6e, 0x61, 0,
0x64, 0x69, 0x61, 0x72, 0x69, 0x6f, 0,
0x64, 0x69, 0x62, 0x75, 0x6a, 0x6f, 0,
0x64, 0x69, 0x63, 0x74, 0x61, 0x72, 0,
0x64, 0x69, 0x65, 0x6e, 0x74, 0x65, 0,
0x64, 0x69, 0x65, 0x74, 0x61, 0,
0x64, 0x69, 0x65, 0x7a, 0,
0x64, 0x69, 0x66, 0x69, 0xcc, 0x81, 0x63, 0x69, 0x6c, 0,
0x64, 0x69, 0x67, 0x6e, 0x6f, 0,
0x64, 0x69, 0x6c, 0x65, 0x6d, 0x61, 0,
0x64, 0x69, 0x6c, 0x75, 0x69, 0x72, 0,
0x64, 0x69, 0x6e, 0x65, 0x72, 0x6f, 0,
0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0,
0x64, 0x69, 0x72, 0x69, 0x67, 0x69, 0x72, 0,
0x64, 0x69, 0x73, 0x63, 0x6f, 0,
0x64, 0x69, 0x73, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x64, 0x69, 0x73, 0x66, 0x72, 0x61, 0x7a, 0,
0x64, 0x69, 0x76, 0x61, 0,
0x64, 0x69, 0x76, 0x69, 0x6e, 0x6f, 0,
0x64, 0x6f, 0x62, 0x6c, 0x65, 0,
0x64, 0x6f, 0x63, 0x65, 0,
0x64, 0x6f, 0x6c, 0x6f, 0x72, 0,
0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x6f, 0,
0x64, 0x6f, 0x6e, 0,
0x64, 0x6f, 0x6e, 0x61, 0x72, 0,
0x64, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0,
0x64, 0x6f, 0x72, 0x6d, 0x69, 0x72, 0,
0x64, 0x6f, 0x72, 0x73, 0x6f, 0,
0x64, 0x6f, 0x73, 0,
0x64, 0x6f, 0x73, 0x69, 0x73, 0,
0x64, 0x72, 0x61, 0x67, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x64, 0x72, 0x6f, 0x67, 0x61, 0,
0x64, 0x75, 0x63, 0x68, 0x61, 0,
0x64, 0x75, 0x64, 0x61, 0,
0x64, 0x75, 0x65, 0x6c, 0x6f, 0,
0x64, 0x75, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x64, 0x75, 0x6c, 0x63, 0x65, 0,
0x64, 0x75, 0xcc, 0x81, 0x6f, 0,
0x64, 0x75, 0x71, 0x75, 0x65, 0,
0x64, 0x75, 0x72, 0x61, 0x72, 0,
0x64, 0x75, 0x72, 0x65, 0x7a, 0x61, 0,
0x64, 0x75, 0x72, 0x6f, 0,
0x65, 0xcc, 0x81, 0x62, 0x61, 0x6e, 0x6f, 0,
0x65, 0x62, 0x72, 0x69, 0x6f, 0,
0x65, 0x63, 0x68, 0x61, 0x72, 0,
0x65, 0x63, 0x6f, 0,
0x65, 0x63, 0x75, 0x61, 0x64, 0x6f, 0x72, 0,
0x65, 0x64, 0x61, 0x64, 0,
0x65, 0x64, 0x69, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x65, 0x64, 0x69, 0x66, 0x69, 0x63, 0x69, 0x6f, 0,
0x65, 0x64, 0x69, 0x74, 0x6f, 0x72, 0,
0x65, 0x64, 0x75, 0x63, 0x61, 0x72, 0,
0x65, 0x66, 0x65, 0x63, 0x74, 0x6f, 0,
0x65, 0x66, 0x69, 0x63, 0x61, 0x7a, 0,
0x65, 0x6a, 0x65, 0,
0x65, 0x6a, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0,
0x65, 0x6c, 0x65, 0x66, 0x61, 0x6e, 0x74, 0x65, 0,
0x65, 0x6c, 0x65, 0x67, 0x69, 0x72, 0,
0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0,
0x65, 0x6c, 0x65, 0x76, 0x61, 0x72, 0,
0x65, 0x6c, 0x69, 0x70, 0x73, 0x65, 0,
0x65, 0xcc, 0x81, 0x6c, 0x69, 0x74, 0x65, 0,
0x65, 0x6c, 0x69, 0x78, 0x69, 0x72, 0,
0x65, 0x6c, 0x6f, 0x67, 0x69, 0x6f, 0,
0x65, 0x6c, 0x75, 0x64, 0x69, 0x72, 0,
0x65, 0x6d, 0x62, 0x75, 0x64, 0x6f, 0,
0x65, 0x6d, 0x69, 0x74, 0x69, 0x72, 0,
0x65, 0x6d, 0x6f, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x65, 0x6d, 0x70, 0x61, 0x74, 0x65, 0,
0x65, 0x6d, 0x70, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x65, 0x6d, 0x70, 0x6c, 0x65, 0x6f, 0,
0x65, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x61, 0,
0x65, 0x6e, 0x61, 0x6e, 0x6f, 0,
0x65, 0x6e, 0x63, 0x61, 0x72, 0x67, 0x6f, 0,
0x65, 0x6e, 0x63, 0x68, 0x75, 0x66, 0x65, 0,
0x65, 0x6e, 0x63, 0x69, 0xcc, 0x81, 0x61, 0,
0x65, 0x6e, 0x65, 0x6d, 0x69, 0x67, 0x6f, 0,
0x65, 0x6e, 0x65, 0x72, 0x6f, 0,
0x65, 0x6e, 0x66, 0x61, 0x64, 0x6f, 0,
0x65, 0x6e, 0x66, 0x65, 0x72, 0x6d, 0x6f, 0,
0x65, 0x6e, 0x67, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x65, 0x6e, 0x69, 0x67, 0x6d, 0x61, 0,
0x65, 0x6e, 0x6c, 0x61, 0x63, 0x65, 0,
0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x65, 0,
0x65, 0x6e, 0x72, 0x65, 0x64, 0x6f, 0,
0x65, 0x6e, 0x73, 0x61, 0x79, 0x6f, 0,
0x65, 0x6e, 0x73, 0x65, 0x6e, 0xcc, 0x83, 0x61, 0x72, 0,
0x65, 0x6e, 0x74, 0x65, 0x72, 0x6f, 0,
0x65, 0x6e, 0x74, 0x72, 0x61, 0x72, 0,
0x65, 0x6e, 0x76, 0x61, 0x73, 0x65, 0,
0x65, 0x6e, 0x76, 0x69, 0xcc, 0x81, 0x6f, 0,
0x65, 0xcc, 0x81, 0x70, 0x6f, 0x63, 0x61, 0,
0x65, 0x71, 0x75, 0x69, 0x70, 0x6f, 0,
0x65, 0x72, 0x69, 0x7a, 0x6f, 0,
0x65, 0x73, 0x63, 0x61, 0x6c, 0x61, 0,
0x65, 0x73, 0x63, 0x65, 0x6e, 0x61, 0,
0x65, 0x73, 0x63, 0x6f, 0x6c, 0x61, 0x72, 0,
0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x72, 0,
0x65, 0x73, 0x63, 0x75, 0x64, 0x6f, 0,
0x65, 0x73, 0x65, 0x6e, 0x63, 0x69, 0x61, 0,
0x65, 0x73, 0x66, 0x65, 0x72, 0x61, 0,
0x65, 0x73, 0x66, 0x75, 0x65, 0x72, 0x7a, 0x6f, 0,
0x65, 0x73, 0x70, 0x61, 0x64, 0x61, 0,
0x65, 0x73, 0x70, 0x65, 0x6a, 0x6f, 0,
0x65, 0x73, 0x70, 0x69, 0xcc, 0x81, 0x61, 0,
0x65, 0x73, 0x70, 0x6f, 0x73, 0x61, 0,
0x65, 0x73, 0x70, 0x75, 0x6d, 0x61, 0,
0x65, 0x73, 0x71, 0x75, 0x69, 0xcc, 0x81, 0,
0x65, 0x73, 0x74, 0x61, 0x72, 0,
0x65, 0x73, 0x74, 0x65, 0,
0x65, 0x73, 0x74, 0x69, 0x6c, 0x6f, 0,
0x65, 0x73, 0x74, 0x75, 0x66, 0x61, 0,
0x65, 0x74, 0x61, 0x70, 0x61, 0,
0x65, 0x74, 0x65, 0x72, 0x6e, 0x6f, 0,
0x65, 0xcc, 0x81, 0x74, 0x69, 0x63, 0x61, 0,
0x65, 0x74, 0x6e, 0x69, 0x61, 0,
0x65, 0x76, 0x61, 0x64, 0x69, 0x72, 0,
0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x72, 0,
0x65, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0,
0x65, 0x76, 0x69, 0x74, 0x61, 0x72, 0,
0x65, 0x78, 0x61, 0x63, 0x74, 0x6f, 0,
0x65, 0x78, 0x61, 0x6d, 0x65, 0x6e, 0,
0x65, 0x78, 0x63, 0x65, 0x73, 0x6f, 0,
0x65, 0x78, 0x63, 0x75, 0x73, 0x61, 0,
0x65, 0x78, 0x65, 0x6e, 0x74, 0x6f, 0,
0x65, 0x78, 0x69, 0x67, 0x69, 0x72, 0,
0x65, 0x78, 0x69, 0x6c, 0x69, 0x6f, 0,
0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x72, 0,
0x65, 0xcc, 0x81, 0x78, 0x69, 0x74, 0x6f, 0,
0x65, 0x78, 0x70, 0x65, 0x72, 0x74, 0x6f, 0,
0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x72, 0,
0x65, 0x78, 0x70, 0x6f, 0x6e, 0x65, 0x72, 0,
0x65, 0x78, 0x74, 0x72, 0x65, 0x6d, 0x6f, 0,
0x66, 0x61, 0xcc, 0x81, 0x62, 0x72, 0x69, 0x63, 0x61, 0,
0x66, 0x61, 0xcc, 0x81, 0x62, 0x75, 0x6c, 0x61, 0,
0x66, 0x61, 0x63, 0x68, 0x61, 0x64, 0x61, 0,
0x66, 0x61, 0xcc, 0x81, 0x63, 0x69, 0x6c, 0,
0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0,
0x66, 0x61, 0x65, 0x6e, 0x61, 0,
0x66, 0x61, 0x6a, 0x61, 0,
0x66, 0x61, 0x6c, 0x64, 0x61, 0,
0x66, 0x61, 0x6c, 0x6c, 0x6f, 0,
0x66, 0x61, 0x6c, 0x73, 0x6f, 0,
0x66, 0x61, 0x6c, 0x74, 0x61, 0x72, 0,
0x66, 0x61, 0x6d, 0x61, 0,
0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x61, 0,
0x66, 0x61, 0x6d, 0x6f, 0x73, 0x6f, 0,
0x66, 0x61, 0x72, 0x61, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x66, 0x61, 0x72, 0x6d, 0x61, 0x63, 0x69, 0x61, 0,
0x66, 0x61, 0x72, 0x6f, 0x6c, 0,
0x66, 0x61, 0x72, 0x73, 0x61, 0,
0x66, 0x61, 0x73, 0x65, 0,
0x66, 0x61, 0x74, 0x69, 0x67, 0x61, 0,
0x66, 0x61, 0x75, 0x6e, 0x61, 0,
0x66, 0x61, 0x76, 0x6f, 0x72, 0,
0x66, 0x61, 0x78, 0,
0x66, 0x65, 0x62, 0x72, 0x65, 0x72, 0x6f, 0,
0x66, 0x65, 0x63, 0x68, 0x61, 0,
0x66, 0x65, 0x6c, 0x69, 0x7a, 0,
0x66, 0x65, 0x6f, 0,
0x66, 0x65, 0x72, 0x69, 0x61, 0,
0x66, 0x65, 0x72, 0x6f, 0x7a, 0,
0x66, 0x65, 0xcc, 0x81, 0x72, 0x74, 0x69, 0x6c, 0,
0x66, 0x65, 0x72, 0x76, 0x6f, 0x72, 0,
0x66, 0x65, 0x73, 0x74, 0x69, 0xcc, 0x81, 0x6e, 0,
0x66, 0x69, 0x61, 0x62, 0x6c, 0x65, 0,
0x66, 0x69, 0x61, 0x6e, 0x7a, 0x61, 0,
0x66, 0x69, 0x61, 0x72, 0,
0x66, 0x69, 0x62, 0x72, 0x61, 0,
0x66, 0x69, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x66, 0x69, 0x63, 0x68, 0x61, 0,
0x66, 0x69, 0x64, 0x65, 0x6f, 0,
0x66, 0x69, 0x65, 0x62, 0x72, 0x65, 0,
0x66, 0x69, 0x65, 0x6c, 0,
0x66, 0x69, 0x65, 0x72, 0x61, 0,
0x66, 0x69, 0x65, 0x73, 0x74, 0x61, 0,
0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0,
0x66, 0x69, 0x6a, 0x61, 0x72, 0,
0x66, 0x69, 0x6a, 0x6f, 0,
0x66, 0x69, 0x6c, 0x61, 0,
0x66, 0x69, 0x6c, 0x65, 0x74, 0x65, 0,
0x66, 0x69, 0x6c, 0x69, 0x61, 0x6c, 0,
0x66, 0x69, 0x6c, 0x74, 0x72, 0x6f, 0,
0x66, 0x69, 0x6e, 0,
0x66, 0x69, 0x6e, 0x63, 0x61, 0,
0x66, 0x69, 0x6e, 0x67, 0x69, 0x72, 0,
0x66, 0x69, 0x6e, 0x69, 0x74, 0x6f, 0,
0x66, 0x69, 0x72, 0x6d, 0x61, 0,
0x66, 0x6c, 0x61, 0x63, 0x6f, 0,
0x66, 0x6c, 0x61, 0x75, 0x74, 0x61, 0,
0x66, 0x6c, 0x65, 0x63, 0x68, 0x61, 0,
0x66, 0x6c, 0x6f, 0x72, 0,
0x66, 0x6c, 0x6f, 0x74, 0x61, 0,
0x66, 0x6c, 0x75, 0x69, 0x72, 0,
0x66, 0x6c, 0x75, 0x6a, 0x6f, 0,
0x66, 0x6c, 0x75, 0xcc, 0x81, 0x6f, 0x72, 0,
0x66, 0x6f, 0x62, 0x69, 0x61, 0,
0x66, 0x6f, 0x63, 0x61, 0,
0x66, 0x6f, 0x67, 0x61, 0x74, 0x61, 0,
0x66, 0x6f, 0x67, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x66, 0x6f, 0x6c, 0x69, 0x6f, 0,
0x66, 0x6f, 0x6c, 0x6c, 0x65, 0x74, 0x6f, 0,
0x66, 0x6f, 0x6e, 0x64, 0x6f, 0,
0x66, 0x6f, 0x72, 0x6d, 0x61, 0,
0x66, 0x6f, 0x72, 0x72, 0x6f, 0,
0x66, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x61, 0,
0x66, 0x6f, 0x72, 0x7a, 0x61, 0x72, 0,
0x66, 0x6f, 0x73, 0x61, 0,
0x66, 0x6f, 0x74, 0x6f, 0,
0x66, 0x72, 0x61, 0x63, 0x61, 0x73, 0x6f, 0,
0x66, 0x72, 0x61, 0xcc, 0x81, 0x67, 0x69, 0x6c, 0,
0x66, 0x72, 0x61, 0x6e, 0x6a, 0x61, 0,
0x66, 0x72, 0x61, 0x73, 0x65, 0,
0x66, 0x72, 0x61, 0x75, 0x64, 0x65, 0,
0x66, 0x72, 0x65, 0x69, 0xcc, 0x81, 0x72, 0,
0x66, 0x72, 0x65, 0x6e, 0x6f, 0,
0x66, 0x72, 0x65, 0x73, 0x61, 0,
0x66, 0x72, 0x69, 0xcc, 0x81, 0x6f, 0,
0x66, 0x72, 0x69, 0x74, 0x6f, 0,
0x66, 0x72, 0x75, 0x74, 0x61, 0,
0x66, 0x75, 0x65, 0x67, 0x6f, 0,
0x66, 0x75, 0x65, 0x6e, 0x74, 0x65, 0,
0x66, 0x75, 0x65, 0x72, 0x7a, 0x61, 0,
0x66, 0x75, 0x67, 0x61, 0,
0x66, 0x75, 0x6d, 0x61, 0x72, 0,
0x66, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x66, 0x75, 0x6e, 0x64, 0x61, 0,
0x66, 0x75, 0x72, 0x67, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x66, 0x75, 0x72, 0x69, 0x61, 0,
0x66, 0x75, 0x73, 0x69, 0x6c, 0,
0x66, 0x75, 0xcc, 0x81, 0x74, 0x62, 0x6f, 0x6c, 0,
0x66, 0x75, 0x74, 0x75, 0x72, 0x6f, 0,
0x67, 0x61, 0x63, 0x65, 0x6c, 0x61, 0,
0x67, 0x61, 0x66, 0x61, 0x73, 0,
0x67, 0x61, 0x69, 0x74, 0x61, 0,
0x67, 0x61, 0x6a, 0x6f, 0,
0x67, 0x61, 0x6c, 0x61, 0,
0x67, 0x61, 0x6c, 0x65, 0x72, 0x69, 0xcc, 0x81, 0x61, 0,
0x67, 0x61, 0x6c, 0x6c, 0x6f, 0,
0x67, 0x61, 0x6d, 0x62, 0x61, 0,
0x67, 0x61, 0x6e, 0x61, 0x72, 0,
0x67, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0,
0x67, 0x61, 0x6e, 0x67, 0x61, 0,
0x67, 0x61, 0x6e, 0x73, 0x6f, 0,
0x67, 0x61, 0x72, 0x61, 0x6a, 0x65, 0,
0x67, 0x61, 0x72, 0x7a, 0x61, 0,
0x67, 0x61, 0x73, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0,
0x67, 0x61, 0x73, 0x74, 0x61, 0x72, 0,
0x67, 0x61, 0x74, 0x6f, 0,
0x67, 0x61, 0x76, 0x69, 0x6c, 0x61, 0xcc, 0x81, 0x6e, 0,
0x67, 0x65, 0x6d, 0x65, 0x6c, 0x6f, 0,
0x67, 0x65, 0x6d, 0x69, 0x72, 0,
0x67, 0x65, 0x6e, 0,
0x67, 0x65, 0xcc, 0x81, 0x6e, 0x65, 0x72, 0x6f, 0,
0x67, 0x65, 0x6e, 0x69, 0x6f, 0,
0x67, 0x65, 0x6e, 0x74, 0x65, 0,
0x67, 0x65, 0x72, 0x61, 0x6e, 0x69, 0x6f, 0,
0x67, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x65, 0,
0x67, 0x65, 0x72, 0x6d, 0x65, 0x6e, 0,
0x67, 0x65, 0x73, 0x74, 0x6f, 0,
0x67, 0x69, 0x67, 0x61, 0x6e, 0x74, 0x65, 0,
0x67, 0x69, 0x6d, 0x6e, 0x61, 0x73, 0x69, 0x6f, 0,
0x67, 0x69, 0x72, 0x61, 0x72, 0,
0x67, 0x69, 0x72, 0x6f, 0,
0x67, 0x6c, 0x61, 0x63, 0x69, 0x61, 0x72, 0,
0x67, 0x6c, 0x6f, 0x62, 0x6f, 0,
0x67, 0x6c, 0x6f, 0x72, 0x69, 0x61, 0,
0x67, 0x6f, 0x6c, 0,
0x67, 0x6f, 0x6c, 0x66, 0x6f, 0,
0x67, 0x6f, 0x6c, 0x6f, 0x73, 0x6f, 0,
0x67, 0x6f, 0x6c, 0x70, 0x65, 0,
0x67, 0x6f, 0x6d, 0x61, 0,
0x67, 0x6f, 0x72, 0x64, 0x6f, 0,
0x67, 0x6f, 0x72, 0x69, 0x6c, 0x61, 0,
0x67, 0x6f, 0x72, 0x72, 0x61, 0,
0x67, 0x6f, 0x74, 0x61, 0,
0x67, 0x6f, 0x74, 0x65, 0x6f, 0,
0x67, 0x6f, 0x7a, 0x61, 0x72, 0,
0x67, 0x72, 0x61, 0x64, 0x61, 0,
0x67, 0x72, 0x61, 0xcc, 0x81, 0x66, 0x69, 0x63, 0x6f, 0,
0x67, 0x72, 0x61, 0x6e, 0x6f, 0,
0x67, 0x72, 0x61, 0x73, 0x61, 0,
0x67, 0x72, 0x61, 0x74, 0x69, 0x73, 0,
0x67, 0x72, 0x61, 0x76, 0x65, 0,
0x67, 0x72, 0x69, 0x65, 0x74, 0x61, 0,
0x67, 0x72, 0x69, 0x6c, 0x6c, 0x6f, 0,
0x67, 0x72, 0x69, 0x70, 0x65, 0,
0x67, 0x72, 0x69, 0x73, 0,
0x67, 0x72, 0x69, 0x74, 0x6f, 0,
0x67, 0x72, 0x6f, 0x73, 0x6f, 0x72, 0,
0x67, 0x72, 0x75, 0xcc, 0x81, 0x61, 0,
0x67, 0x72, 0x75, 0x65, 0x73, 0x6f, 0,
0x67, 0x72, 0x75, 0x6d, 0x6f, 0,
0x67, 0x72, 0x75, 0x70, 0x6f, 0,
0x67, 0x75, 0x61, 0x6e, 0x74, 0x65, 0,
0x67, 0x75, 0x61, 0x70, 0x6f, 0,
0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0,
0x67, 0x75, 0x65, 0x72, 0x72, 0x61, 0,
0x67, 0x75, 0x69, 0xcc, 0x81, 0x61, 0,
0x67, 0x75, 0x69, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x67, 0x75, 0x69, 0x6f, 0x6e, 0,
0x67, 0x75, 0x69, 0x73, 0x6f, 0,
0x67, 0x75, 0x69, 0x74, 0x61, 0x72, 0x72, 0x61, 0,
0x67, 0x75, 0x73, 0x61, 0x6e, 0x6f, 0,
0x67, 0x75, 0x73, 0x74, 0x61, 0x72, 0,
0x68, 0x61, 0x62, 0x65, 0x72, 0,
0x68, 0x61, 0xcc, 0x81, 0x62, 0x69, 0x6c, 0,
0x68, 0x61, 0x62, 0x6c, 0x61, 0x72, 0,
0x68, 0x61, 0x63, 0x65, 0x72, 0,
0x68, 0x61, 0x63, 0x68, 0x61, 0,
0x68, 0x61, 0x64, 0x61, 0,
0x68, 0x61, 0x6c, 0x6c, 0x61, 0x72, 0,
0x68, 0x61, 0x6d, 0x61, 0x63, 0x61, 0,
0x68, 0x61, 0x72, 0x69, 0x6e, 0x61, 0,
0x68, 0x61, 0x7a, 0,
0x68, 0x61, 0x7a, 0x61, 0x6e, 0xcc, 0x83, 0x61, 0,
0x68, 0x65, 0x62, 0x69, 0x6c, 0x6c, 0x61, 0,
0x68, 0x65, 0x62, 0x72, 0x61, 0,
0x68, 0x65, 0x63, 0x68, 0x6f, 0,
0x68, 0x65, 0x6c, 0x61, 0x64, 0x6f, 0,
0x68, 0x65, 0x6c, 0x69, 0x6f, 0,
0x68, 0x65, 0x6d, 0x62, 0x72, 0x61, 0,
0x68, 0x65, 0x72, 0x69, 0x72, 0,
0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x6f, 0,
0x68, 0x65, 0xcc, 0x81, 0x72, 0x6f, 0x65, 0,
0x68, 0x65, 0x72, 0x76, 0x69, 0x72, 0,
0x68, 0x69, 0x65, 0x6c, 0x6f, 0,
0x68, 0x69, 0x65, 0x72, 0x72, 0x6f, 0,
0x68, 0x69, 0xcc, 0x81, 0x67, 0x61, 0x64, 0x6f, 0,
0x68, 0x69, 0x67, 0x69, 0x65, 0x6e, 0x65, 0,
0x68, 0x69, 0x6a, 0x6f, 0,
0x68, 0x69, 0x6d, 0x6e, 0x6f, 0,
0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0,
0x68, 0x6f, 0x63, 0x69, 0x63, 0x6f, 0,
0x68, 0x6f, 0x67, 0x61, 0x72, 0,
0x68, 0x6f, 0x67, 0x75, 0x65, 0x72, 0x61, 0,
0x68, 0x6f, 0x6a, 0x61, 0,
0x68, 0x6f, 0x6d, 0x62, 0x72, 0x65, 0,
0x68, 0x6f, 0x6e, 0x67, 0x6f, 0,
0x68, 0x6f, 0x6e, 0x6f, 0x72, 0,
0x68, 0x6f, 0x6e, 0x72, 0x61, 0,
0x68, 0x6f, 0x72, 0x61, 0,
0x68, 0x6f, 0x72, 0x6d, 0x69, 0x67, 0x61, 0,
0x68, 0x6f, 0x72, 0x6e, 0x6f, 0,
0x68, 0x6f, 0x73, 0x74, 0x69, 0x6c, 0,
0x68, 0x6f, 0x79, 0x6f, 0,
0x68, 0x75, 0x65, 0x63, 0x6f, 0,
0x68, 0x75, 0x65, 0x6c, 0x67, 0x61, 0,
0x68, 0x75, 0x65, 0x72, 0x74, 0x61, 0,
0x68, 0x75, 0x65, 0x73, 0x6f, 0,
0x68, 0x75, 0x65, 0x76, 0x6f, 0,
0x68, 0x75, 0x69, 0x64, 0x61, 0,
0x68, 0x75, 0x69, 0x72, 0,
0x68, 0x75, 0x6d, 0x61, 0x6e, 0x6f, 0,
0x68, 0x75, 0xcc, 0x81, 0x6d, 0x65, 0x64, 0x6f, 0,
0x68, 0x75, 0x6d, 0x69, 0x6c, 0x64, 0x65, 0,
0x68, 0x75, 0x6d, 0x6f, 0,
0x68, 0x75, 0x6e, 0x64, 0x69, 0x72, 0,
0x68, 0x75, 0x72, 0x61, 0x63, 0x61, 0xcc, 0x81, 0x6e, 0,
0x68, 0x75, 0x72, 0x74, 0x6f, 0,
0x69, 0x63, 0x6f, 0x6e, 0x6f, 0,
0x69, 0x64, 0x65, 0x61, 0x6c, 0,
0x69, 0x64, 0x69, 0x6f, 0x6d, 0x61, 0,
0x69, 0xcc, 0x81, 0x64, 0x6f, 0x6c, 0x6f, 0,
0x69, 0x67, 0x6c, 0x65, 0x73, 0x69, 0x61, 0,
0x69, 0x67, 0x6c, 0x75, 0xcc, 0x81, 0,
0x69, 0x67, 0x75, 0x61, 0x6c, 0,
0x69, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0,
0x69, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x69, 0x6d, 0x61, 0x67, 0x65, 0x6e, 0,
0x69, 0x6d, 0x61, 0xcc, 0x81, 0x6e, 0,
0x69, 0x6d, 0x69, 0x74, 0x61, 0x72, 0,
0x69, 0x6d, 0x70, 0x61, 0x72, 0,
0x69, 0x6d, 0x70, 0x65, 0x72, 0x69, 0x6f, 0,
0x69, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x72, 0,
0x69, 0x6d, 0x70, 0x75, 0x6c, 0x73, 0x6f, 0,
0x69, 0x6e, 0x63, 0x61, 0x70, 0x61, 0x7a, 0,
0x69, 0xcc, 0x81, 0x6e, 0x64, 0x69, 0x63, 0x65, 0,
0x69, 0x6e, 0x65, 0x72, 0x74, 0x65, 0,
0x69, 0x6e, 0x66, 0x69, 0x65, 0x6c, 0,
0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0,
0x69, 0x6e, 0x67, 0x65, 0x6e, 0x69, 0x6f, 0,
0x69, 0x6e, 0x69, 0x63, 0x69, 0x6f, 0,
0x69, 0x6e, 0x6d, 0x65, 0x6e, 0x73, 0x6f, 0,
0x69, 0x6e, 0x6d, 0x75, 0x6e, 0x65, 0,
0x69, 0x6e, 0x6e, 0x61, 0x74, 0x6f, 0,
0x69, 0x6e, 0x73, 0x65, 0x63, 0x74, 0x6f, 0,
0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x65, 0,
0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0xcc, 0x81, 0x73, 0,
0x69, 0xcc, 0x81, 0x6e, 0x74, 0x69, 0x6d, 0x6f, 0,
0x69, 0x6e, 0x74, 0x75, 0x69, 0x72, 0,
0x69, 0x6e, 0x75, 0xcc, 0x81, 0x74, 0x69, 0x6c, 0,
0x69, 0x6e, 0x76, 0x69, 0x65, 0x72, 0x6e, 0x6f, 0,
0x69, 0x72, 0x61, 0,
0x69, 0x72, 0x69, 0x73, 0,
0x69, 0x72, 0x6f, 0x6e, 0x69, 0xcc, 0x81, 0x61, 0,
0x69, 0x73, 0x6c, 0x61, 0,
0x69, 0x73, 0x6c, 0x6f, 0x74, 0x65, 0,
0x6a, 0x61, 0x62, 0x61, 0x6c, 0x69, 0xcc, 0x81, 0,
0x6a, 0x61, 0x62, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6a, 0x61, 0x6d, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6a, 0x61, 0x72, 0x61, 0x62, 0x65, 0,
0x6a, 0x61, 0x72, 0x64, 0x69, 0xcc, 0x81, 0x6e, 0,
0x6a, 0x61, 0x72, 0x72, 0x61, 0,
0x6a, 0x61, 0x75, 0x6c, 0x61, 0,
0x6a, 0x61, 0x7a, 0x6d, 0x69, 0xcc, 0x81, 0x6e, 0,
0x6a, 0x65, 0x66, 0x65, 0,
0x6a, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x61, 0,
0x6a, 0x69, 0x6e, 0x65, 0x74, 0x65, 0,
0x6a, 0x6f, 0x72, 0x6e, 0x61, 0x64, 0x61, 0,
0x6a, 0x6f, 0x72, 0x6f, 0x62, 0x61, 0,
0x6a, 0x6f, 0x76, 0x65, 0x6e, 0,
0x6a, 0x6f, 0x79, 0x61, 0,
0x6a, 0x75, 0x65, 0x72, 0x67, 0x61, 0,
0x6a, 0x75, 0x65, 0x76, 0x65, 0x73, 0,
0x6a, 0x75, 0x65, 0x7a, 0,
0x6a, 0x75, 0x67, 0x61, 0x64, 0x6f, 0x72, 0,
0x6a, 0x75, 0x67, 0x6f, 0,
0x6a, 0x75, 0x67, 0x75, 0x65, 0x74, 0x65, 0,
0x6a, 0x75, 0x69, 0x63, 0x69, 0x6f, 0,
0x6a, 0x75, 0x6e, 0x63, 0x6f, 0,
0x6a, 0x75, 0x6e, 0x67, 0x6c, 0x61, 0,
0x6a, 0x75, 0x6e, 0x69, 0x6f, 0,
0x6a, 0x75, 0x6e, 0x74, 0x61, 0x72, 0,
0x6a, 0x75, 0xcc, 0x81, 0x70, 0x69, 0x74, 0x65, 0x72, 0,
0x6a, 0x75, 0x72, 0x61, 0x72, 0,
0x6a, 0x75, 0x73, 0x74, 0x6f, 0,
0x6a, 0x75, 0x76, 0x65, 0x6e, 0x69, 0x6c, 0,
0x6a, 0x75, 0x7a, 0x67, 0x61, 0x72, 0,
0x6b, 0x69, 0x6c, 0x6f, 0,
0x6b, 0x6f, 0x61, 0x6c, 0x61, 0,
0x6c, 0x61, 0x62, 0x69, 0x6f, 0,
0x6c, 0x61, 0x63, 0x69, 0x6f, 0,
0x6c, 0x61, 0x63, 0x72, 0x61, 0,
0x6c, 0x61, 0x64, 0x6f, 0,
0x6c, 0x61, 0x64, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x61, 0x67, 0x61, 0x72, 0x74, 0x6f, 0,
0x6c, 0x61, 0xcc, 0x81, 0x67, 0x72, 0x69, 0x6d, 0x61, 0,
0x6c, 0x61, 0x67, 0x75, 0x6e, 0x61, 0,
0x6c, 0x61, 0x69, 0x63, 0x6f, 0,
0x6c, 0x61, 0x6d, 0x65, 0x72, 0,
0x6c, 0x61, 0xcc, 0x81, 0x6d, 0x69, 0x6e, 0x61, 0,
0x6c, 0x61, 0xcc, 0x81, 0x6d, 0x70, 0x61, 0x72, 0x61, 0,
0x6c, 0x61, 0x6e, 0x61, 0,
0x6c, 0x61, 0x6e, 0x63, 0x68, 0x61, 0,
0x6c, 0x61, 0x6e, 0x67, 0x6f, 0x73, 0x74, 0x61, 0,
0x6c, 0x61, 0x6e, 0x7a, 0x61, 0,
0x6c, 0x61, 0xcc, 0x81, 0x70, 0x69, 0x7a, 0,
0x6c, 0x61, 0x72, 0x67, 0x6f, 0,
0x6c, 0x61, 0x72, 0x76, 0x61, 0,
0x6c, 0x61, 0xcc, 0x81, 0x73, 0x74, 0x69, 0x6d, 0x61, 0,
0x6c, 0x61, 0x74, 0x61, 0,
0x6c, 0x61, 0xcc, 0x81, 0x74, 0x65, 0x78, 0,
0x6c, 0x61, 0x74, 0x69, 0x72, 0,
0x6c, 0x61, 0x75, 0x72, 0x65, 0x6c, 0,
0x6c, 0x61, 0x76, 0x61, 0x72, 0,
0x6c, 0x61, 0x7a, 0x6f, 0,
0x6c, 0x65, 0x61, 0x6c, 0,
0x6c, 0x65, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x65, 0x63, 0x68, 0x65, 0,
0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0,
0x6c, 0x65, 0x65, 0x72, 0,
0x6c, 0x65, 0x67, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x65, 0x67, 0x75, 0x6d, 0x62, 0x72, 0x65, 0,
0x6c, 0x65, 0x6a, 0x61, 0x6e, 0x6f, 0,
0x6c, 0x65, 0x6e, 0x67, 0x75, 0x61, 0,
0x6c, 0x65, 0x6e, 0x74, 0x6f, 0,
0x6c, 0x65, 0x6e, 0xcc, 0x83, 0x61, 0,
0x6c, 0x65, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x65, 0x6f, 0x70, 0x61, 0x72, 0x64, 0x6f, 0,
0x6c, 0x65, 0x73, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x65, 0x74, 0x61, 0x6c, 0,
0x6c, 0x65, 0x74, 0x72, 0x61, 0,
0x6c, 0x65, 0x76, 0x65, 0,
0x6c, 0x65, 0x79, 0x65, 0x6e, 0x64, 0x61, 0,
0x6c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x61, 0x64, 0,
0x6c, 0x69, 0x62, 0x72, 0x6f, 0,
0x6c, 0x69, 0x63, 0x6f, 0x72, 0,
0x6c, 0x69, 0xcc, 0x81, 0x64, 0x65, 0x72, 0,
0x6c, 0x69, 0x64, 0x69, 0x61, 0x72, 0,
0x6c, 0x69, 0x65, 0x6e, 0x7a, 0x6f, 0,
0x6c, 0x69, 0x67, 0x61, 0,
0x6c, 0x69, 0x67, 0x65, 0x72, 0x6f, 0,
0x6c, 0x69, 0x6d, 0x61, 0,
0x6c, 0x69, 0xcc, 0x81, 0x6d, 0x69, 0x74, 0x65, 0,
0x6c, 0x69, 0x6d, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x69, 0x6d, 0x70, 0x69, 0x6f, 0,
0x6c, 0x69, 0x6e, 0x63, 0x65, 0,
0x6c, 0x69, 0x6e, 0x64, 0x6f, 0,
0x6c, 0x69, 0xcc, 0x81, 0x6e, 0x65, 0x61, 0,
0x6c, 0x69, 0x6e, 0x67, 0x6f, 0x74, 0x65, 0,
0x6c, 0x69, 0x6e, 0x6f, 0,
0x6c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0,
0x6c, 0x69, 0xcc, 0x81, 0x71, 0x75, 0x69, 0x64, 0x6f, 0,
0x6c, 0x69, 0x73, 0x6f, 0,
0x6c, 0x69, 0x73, 0x74, 0x61, 0,
0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0,
0x6c, 0x69, 0x74, 0x69, 0x6f, 0,
0x6c, 0x69, 0x74, 0x72, 0x6f, 0,
0x6c, 0x6c, 0x61, 0x67, 0x61, 0,
0x6c, 0x6c, 0x61, 0x6d, 0x61, 0,
0x6c, 0x6c, 0x61, 0x6e, 0x74, 0x6f, 0,
0x6c, 0x6c, 0x61, 0x76, 0x65, 0,
0x6c, 0x6c, 0x65, 0x67, 0x61, 0x72, 0,
0x6c, 0x6c, 0x65, 0x6e, 0x61, 0x72, 0,
0x6c, 0x6c, 0x65, 0x76, 0x61, 0x72, 0,
0x6c, 0x6c, 0x6f, 0x72, 0x61, 0x72, 0,
0x6c, 0x6c, 0x6f, 0x76, 0x65, 0x72, 0,
0x6c, 0x6c, 0x75, 0x76, 0x69, 0x61, 0,
0x6c, 0x6f, 0x62, 0x6f, 0,
0x6c, 0x6f, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6c, 0x6f, 0x63, 0x6f, 0,
0x6c, 0x6f, 0x63, 0x75, 0x72, 0x61, 0,
0x6c, 0x6f, 0xcc, 0x81, 0x67, 0x69, 0x63, 0x61, 0,
0x6c, 0x6f, 0x67, 0x72, 0x6f, 0,
0x6c, 0x6f, 0x6d, 0x62, 0x72, 0x69, 0x7a, 0,
0x6c, 0x6f, 0x6d, 0x6f, 0,
0x6c, 0x6f, 0x6e, 0x6a, 0x61, 0,
0x6c, 0x6f, 0x74, 0x65, 0,
0x6c, 0x75, 0x63, 0x68, 0x61, 0,
0x6c, 0x75, 0x63, 0x69, 0x72, 0,
0x6c, 0x75, 0x67, 0x61, 0x72, 0,
0x6c, 0x75, 0x6a, 0x6f, 0,
0x6c, 0x75, 0x6e, 0x61, 0,
0x6c, 0x75, 0x6e, 0x65, 0x73, 0,
0x6c, 0x75, 0x70, 0x61, 0,
0x6c, 0x75, 0x73, 0x74, 0x72, 0x6f, 0,
0x6c, 0x75, 0x74, 0x6f, 0,
0x6c, 0x75, 0x7a, 0,
0x6d, 0x61, 0x63, 0x65, 0x74, 0x61, 0,
0x6d, 0x61, 0x63, 0x68, 0x6f, 0,
0x6d, 0x61, 0x64, 0x65, 0x72, 0x61, 0,
0x6d, 0x61, 0x64, 0x72, 0x65, 0,
0x6d, 0x61, 0x64, 0x75, 0x72, 0x6f, 0,
0x6d, 0x61, 0x65, 0x73, 0x74, 0x72, 0x6f, 0,
0x6d, 0x61, 0x66, 0x69, 0x61, 0,
0x6d, 0x61, 0x67, 0x69, 0x61, 0,
0x6d, 0x61, 0x67, 0x6f, 0,
0x6d, 0x61, 0x69, 0xcc, 0x81, 0x7a, 0,
0x6d, 0x61, 0x6c, 0x64, 0x61, 0x64, 0,
0x6d, 0x61, 0x6c, 0x65, 0x74, 0x61, 0,
0x6d, 0x61, 0x6c, 0x6c, 0x61, 0,
0x6d, 0x61, 0x6c, 0x6f, 0,
0x6d, 0x61, 0x6d, 0x61, 0xcc, 0x81, 0,
0x6d, 0x61, 0x6d, 0x62, 0x6f, 0,
0x6d, 0x61, 0x6d, 0x75, 0x74, 0,
0x6d, 0x61, 0x6e, 0x63, 0x6f, 0,
0x6d, 0x61, 0x6e, 0x64, 0x6f, 0,
0x6d, 0x61, 0x6e, 0x65, 0x6a, 0x61, 0x72, 0,
0x6d, 0x61, 0x6e, 0x67, 0x61, 0,
0x6d, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x69, 0xcc, 0x81, 0,
0x6d, 0x61, 0x6e, 0x6a, 0x61, 0x72, 0,
0x6d, 0x61, 0x6e, 0x6f, 0,
0x6d, 0x61, 0x6e, 0x73, 0x6f, 0,
0x6d, 0x61, 0x6e, 0x74, 0x61, 0,
0x6d, 0x61, 0x6e, 0xcc, 0x83, 0x61, 0x6e, 0x61, 0,
0x6d, 0x61, 0x70, 0x61, 0,
0x6d, 0x61, 0xcc, 0x81, 0x71, 0x75, 0x69, 0x6e, 0x61, 0,
0x6d, 0x61, 0x72, 0,
0x6d, 0x61, 0x72, 0x63, 0x6f, 0,
0x6d, 0x61, 0x72, 0x65, 0x61, 0,
0x6d, 0x61, 0x72, 0x66, 0x69, 0x6c, 0,
0x6d, 0x61, 0x72, 0x67, 0x65, 0x6e, 0,
0x6d, 0x61, 0x72, 0x69, 0x64, 0x6f, 0,
0x6d, 0x61, 0xcc, 0x81, 0x72, 0x6d, 0x6f, 0x6c, 0,
0x6d, 0x61, 0x72, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6d, 0x61, 0x72, 0x74, 0x65, 0x73, 0,
0x6d, 0x61, 0x72, 0x7a, 0x6f, 0,
0x6d, 0x61, 0x73, 0x61, 0,
0x6d, 0x61, 0xcc, 0x81, 0x73, 0x63, 0x61, 0x72, 0x61, 0,
0x6d, 0x61, 0x73, 0x69, 0x76, 0x6f, 0,
0x6d, 0x61, 0x74, 0x61, 0x72, 0,
0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0,
0x6d, 0x61, 0x74, 0x69, 0x7a, 0,
0x6d, 0x61, 0x74, 0x72, 0x69, 0x7a, 0,
0x6d, 0x61, 0xcc, 0x81, 0x78, 0x69, 0x6d, 0x6f, 0,
0x6d, 0x61, 0x79, 0x6f, 0x72, 0,
0x6d, 0x61, 0x7a, 0x6f, 0x72, 0x63, 0x61, 0,
0x6d, 0x65, 0x63, 0x68, 0x61, 0,
0x6d, 0x65, 0x64, 0x61, 0x6c, 0x6c, 0x61, 0,
0x6d, 0x65, 0x64, 0x69, 0x6f, 0,
0x6d, 0x65, 0xcc, 0x81, 0x64, 0x75, 0x6c, 0x61, 0,
0x6d, 0x65, 0x6a, 0x69, 0x6c, 0x6c, 0x61, 0,
0x6d, 0x65, 0x6a, 0x6f, 0x72, 0,
0x6d, 0x65, 0x6c, 0x65, 0x6e, 0x61, 0,
0x6d, 0x65, 0x6c, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x69, 0x61, 0,
0x6d, 0x65, 0x6e, 0x6f, 0x72, 0,
0x6d, 0x65, 0x6e, 0x73, 0x61, 0x6a, 0x65, 0,
0x6d, 0x65, 0x6e, 0x74, 0x65, 0,
0x6d, 0x65, 0x6e, 0x75, 0xcc, 0x81, 0,
0x6d, 0x65, 0x72, 0x63, 0x61, 0x64, 0x6f, 0,
0x6d, 0x65, 0x72, 0x65, 0x6e, 0x67, 0x75, 0x65, 0,
0x6d, 0x65, 0xcc, 0x81, 0x72, 0x69, 0x74, 0x6f, 0,
0x6d, 0x65, 0x73, 0,
0x6d, 0x65, 0x73, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6d, 0x65, 0x74, 0x61, 0,
0x6d, 0x65, 0x74, 0x65, 0x72, 0,
0x6d, 0x65, 0xcc, 0x81, 0x74, 0x6f, 0x64, 0x6f, 0,
0x6d, 0x65, 0x74, 0x72, 0x6f, 0,
0x6d, 0x65, 0x7a, 0x63, 0x6c, 0x61, 0,
0x6d, 0x69, 0x65, 0x64, 0x6f, 0,
0x6d, 0x69, 0x65, 0x6c, 0,
0x6d, 0x69, 0x65, 0x6d, 0x62, 0x72, 0x6f, 0,
0x6d, 0x69, 0x67, 0x61, 0,
0x6d, 0x69, 0x6c, 0,
0x6d, 0x69, 0x6c, 0x61, 0x67, 0x72, 0x6f, 0,
0x6d, 0x69, 0x6c, 0x69, 0x74, 0x61, 0x72, 0,
0x6d, 0x69, 0x6c, 0x6c, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6d, 0x69, 0x6d, 0x6f, 0,
0x6d, 0x69, 0x6e, 0x61, 0,
0x6d, 0x69, 0x6e, 0x65, 0x72, 0x6f, 0,
0x6d, 0x69, 0xcc, 0x81, 0x6e, 0x69, 0x6d, 0x6f, 0,
0x6d, 0x69, 0x6e, 0x75, 0x74, 0x6f, 0,
0x6d, 0x69, 0x6f, 0x70, 0x65, 0,
0x6d, 0x69, 0x72, 0x61, 0x72, 0,
0x6d, 0x69, 0x73, 0x61, 0,
0x6d, 0x69, 0x73, 0x65, 0x72, 0x69, 0x61, 0,
0x6d, 0x69, 0x73, 0x69, 0x6c, 0,
0x6d, 0x69, 0x73, 0x6d, 0x6f, 0,
0x6d, 0x69, 0x74, 0x61, 0x64, 0,
0x6d, 0x69, 0x74, 0x6f, 0,
0x6d, 0x6f, 0x63, 0x68, 0x69, 0x6c, 0x61, 0,
0x6d, 0x6f, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6d, 0x6f, 0x64, 0x61, 0,
0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x6f, 0,
0x6d, 0x6f, 0x68, 0x6f, 0,
0x6d, 0x6f, 0x6a, 0x61, 0x72, 0,
0x6d, 0x6f, 0x6c, 0x64, 0x65, 0,
0x6d, 0x6f, 0x6c, 0x65, 0x72, 0,
0x6d, 0x6f, 0x6c, 0x69, 0x6e, 0x6f, 0,
0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x6f, 0,
0x6d, 0x6f, 0x6d, 0x69, 0x61, 0,
0x6d, 0x6f, 0x6e, 0x61, 0x72, 0x63, 0x61, 0,
0x6d, 0x6f, 0x6e, 0x65, 0x64, 0x61, 0,
0x6d, 0x6f, 0x6e, 0x6a, 0x61, 0,
0x6d, 0x6f, 0x6e, 0x74, 0x6f, 0,
0x6d, 0x6f, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x6d, 0x6f, 0x72, 0x61, 0x64, 0x61, 0,
0x6d, 0x6f, 0x72, 0x64, 0x65, 0x72, 0,
0x6d, 0x6f, 0x72, 0x65, 0x6e, 0x6f, 0,
0x6d, 0x6f, 0x72, 0x69, 0x72, 0,
0x6d, 0x6f, 0x72, 0x72, 0x6f, 0,
0x6d, 0x6f, 0x72, 0x73, 0x61, 0,
0x6d, 0x6f, 0x72, 0x74, 0x61, 0x6c, 0,
0x6d, 0x6f, 0x73, 0x63, 0x61, 0,
0x6d, 0x6f, 0x73, 0x74, 0x72, 0x61, 0x72, 0,
0x6d, 0x6f, 0x74, 0x69, 0x76, 0x6f, 0,
0x6d, 0x6f, 0x76, 0x65, 0x72, 0,
0x6d, 0x6f, 0xcc, 0x81, 0x76, 0x69, 0x6c, 0,
0x6d, 0x6f, 0x7a, 0x6f, 0,
0x6d, 0x75, 0x63, 0x68, 0x6f, 0,
0x6d, 0x75, 0x64, 0x61, 0x72, 0,
0x6d, 0x75, 0x65, 0x62, 0x6c, 0x65, 0,
0x6d, 0x75, 0x65, 0x6c, 0x61, 0,
0x6d, 0x75, 0x65, 0x72, 0x74, 0x65, 0,
0x6d, 0x75, 0x65, 0x73, 0x74, 0x72, 0x61, 0,
0x6d, 0x75, 0x67, 0x72, 0x65, 0,
0x6d, 0x75, 0x6a, 0x65, 0x72, 0,
0x6d, 0x75, 0x6c, 0x61, 0,
0x6d, 0x75, 0x6c, 0x65, 0x74, 0x61, 0,
0x6d, 0x75, 0x6c, 0x74, 0x61, 0,
0x6d, 0x75, 0x6e, 0x64, 0x6f, 0,
0x6d, 0x75, 0x6e, 0xcc, 0x83, 0x65, 0x63, 0x61, 0,
0x6d, 0x75, 0x72, 0x61, 0x6c, 0,
0x6d, 0x75, 0x72, 0x6f, 0,
0x6d, 0x75, 0xcc, 0x81, 0x73, 0x63, 0x75, 0x6c, 0x6f, 0,
0x6d, 0x75, 0x73, 0x65, 0x6f, 0,
0x6d, 0x75, 0x73, 0x67, 0x6f, 0,
0x6d, 0x75, 0xcc, 0x81, 0x73, 0x69, 0x63, 0x61, 0,
0x6d, 0x75, 0x73, 0x6c, 0x6f, 0,
0x6e, 0x61, 0xcc, 0x81, 0x63, 0x61, 0x72, 0,
0x6e, 0x61, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6e, 0x61, 0x64, 0x61, 0x72, 0,
0x6e, 0x61, 0x69, 0x70, 0x65, 0,
0x6e, 0x61, 0x72, 0x61, 0x6e, 0x6a, 0x61, 0,
0x6e, 0x61, 0x72, 0x69, 0x7a, 0,
0x6e, 0x61, 0x72, 0x72, 0x61, 0x72, 0,
0x6e, 0x61, 0x73, 0x61, 0x6c, 0,
0x6e, 0x61, 0x74, 0x61, 0x6c, 0,
0x6e, 0x61, 0x74, 0x69, 0x76, 0x6f, 0,
0x6e, 0x61, 0x74, 0x75, 0x72, 0x61, 0x6c, 0,
0x6e, 0x61, 0xcc, 0x81, 0x75, 0x73, 0x65, 0x61, 0,
0x6e, 0x61, 0x76, 0x61, 0x6c, 0,
0x6e, 0x61, 0x76, 0x65, 0,
0x6e, 0x61, 0x76, 0x69, 0x64, 0x61, 0x64, 0,
0x6e, 0x65, 0x63, 0x69, 0x6f, 0,
0x6e, 0x65, 0xcc, 0x81, 0x63, 0x74, 0x61, 0x72, 0,
0x6e, 0x65, 0x67, 0x61, 0x72, 0,
0x6e, 0x65, 0x67, 0x6f, 0x63, 0x69, 0x6f, 0,
0x6e, 0x65, 0x67, 0x72, 0x6f, 0,
0x6e, 0x65, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6e, 0x65, 0x72, 0x76, 0x69, 0x6f, 0,
0x6e, 0x65, 0x74, 0x6f, 0,
0x6e, 0x65, 0x75, 0x74, 0x72, 0x6f, 0,
0x6e, 0x65, 0x76, 0x61, 0x72, 0,
0x6e, 0x65, 0x76, 0x65, 0x72, 0x61, 0,
0x6e, 0x69, 0x63, 0x68, 0x6f, 0,
0x6e, 0x69, 0x64, 0x6f, 0,
0x6e, 0x69, 0x65, 0x62, 0x6c, 0x61, 0,
0x6e, 0x69, 0x65, 0x74, 0x6f, 0,
0x6e, 0x69, 0x6e, 0xcc, 0x83, 0x65, 0x7a, 0,
0x6e, 0x69, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x6e, 0x69, 0xcc, 0x81, 0x74, 0x69, 0x64, 0x6f, 0,
0x6e, 0x69, 0x76, 0x65, 0x6c, 0,
0x6e, 0x6f, 0x62, 0x6c, 0x65, 0x7a, 0x61, 0,
0x6e, 0x6f, 0x63, 0x68, 0x65, 0,
0x6e, 0x6f, 0xcc, 0x81, 0x6d, 0x69, 0x6e, 0x61, 0,
0x6e, 0x6f, 0x72, 0x69, 0x61, 0,
0x6e, 0x6f, 0x72, 0x6d, 0x61, 0,
0x6e, 0x6f, 0x72, 0x74, 0x65, 0,
0x6e, 0x6f, 0x74, 0x61, 0,
0x6e, 0x6f, 0x74, 0x69, 0x63, 0x69, 0x61, 0,
0x6e, 0x6f, 0x76, 0x61, 0x74, 0x6f, 0,
0x6e, 0x6f, 0x76, 0x65, 0x6c, 0x61, 0,
0x6e, 0x6f, 0x76, 0x69, 0x6f, 0,
0x6e, 0x75, 0x62, 0x65, 0,
0x6e, 0x75, 0x63, 0x61, 0,
0x6e, 0x75, 0xcc, 0x81, 0x63, 0x6c, 0x65, 0x6f, 0,
0x6e, 0x75, 0x64, 0x69, 0x6c, 0x6c, 0x6f, 0,
0x6e, 0x75, 0x64, 0x6f, 0,
0x6e, 0x75, 0x65, 0x72, 0x61, 0,
0x6e, 0x75, 0x65, 0x76, 0x65, 0,
0x6e, 0x75, 0x65, 0x7a, 0,
0x6e, 0x75, 0x6c, 0x6f, 0,
0x6e, 0x75, 0xcc, 0x81, 0x6d, 0x65, 0x72, 0x6f, 0,
0x6e, 0x75, 0x74, 0x72, 0x69, 0x61, 0,
0x6f, 0x61, 0x73, 0x69, 0x73, 0,
0x6f, 0x62, 0x65, 0x73, 0x6f, 0,
0x6f, 0x62, 0x69, 0x73, 0x70, 0x6f, 0,
0x6f, 0x62, 0x6a, 0x65, 0x74, 0x6f, 0,
0x6f, 0x62, 0x72, 0x61, 0,
0x6f, 0x62, 0x72, 0x65, 0x72, 0x6f, 0,
0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x72, 0,
0x6f, 0x62, 0x74, 0x65, 0x6e, 0x65, 0x72, 0,
0x6f, 0x62, 0x76, 0x69, 0x6f, 0,
0x6f, 0x63, 0x61, 0,
0x6f, 0x63, 0x61, 0x73, 0x6f, 0,
0x6f, 0x63, 0x65, 0xcc, 0x81, 0x61, 0x6e, 0x6f, 0,
0x6f, 0x63, 0x68, 0x65, 0x6e, 0x74, 0x61, 0,
0x6f, 0x63, 0x68, 0x6f, 0,
0x6f, 0x63, 0x69, 0x6f, 0,
0x6f, 0x63, 0x72, 0x65, 0,
0x6f, 0x63, 0x74, 0x61, 0x76, 0x6f, 0,
0x6f, 0x63, 0x74, 0x75, 0x62, 0x72, 0x65, 0,
0x6f, 0x63, 0x75, 0x6c, 0x74, 0x6f, 0,
0x6f, 0x63, 0x75, 0x70, 0x61, 0x72, 0,
0x6f, 0x63, 0x75, 0x72, 0x72, 0x69, 0x72, 0,
0x6f, 0x64, 0x69, 0x61, 0x72, 0,
0x6f, 0x64, 0x69, 0x6f, 0,
0x6f, 0x64, 0x69, 0x73, 0x65, 0x61, 0,
0x6f, 0x65, 0x73, 0x74, 0x65, 0,
0x6f, 0x66, 0x65, 0x6e, 0x73, 0x61, 0,
0x6f, 0x66, 0x65, 0x72, 0x74, 0x61, 0,
0x6f, 0x66, 0x69, 0x63, 0x69, 0x6f, 0,
0x6f, 0x66, 0x72, 0x65, 0x63, 0x65, 0x72, 0,
0x6f, 0x67, 0x72, 0x6f, 0,
0x6f, 0x69, 0xcc, 0x81, 0x64, 0x6f, 0,
0x6f, 0x69, 0xcc, 0x81, 0x72, 0,
0x6f, 0x6a, 0x6f, 0,
0x6f, 0x6c, 0x61, 0,
0x6f, 0x6c, 0x65, 0x61, 0x64, 0x61, 0,
0x6f, 0x6c, 0x66, 0x61, 0x74, 0x6f, 0,
0x6f, 0x6c, 0x69, 0x76, 0x6f, 0,
0x6f, 0x6c, 0x6c, 0x61, 0,
0x6f, 0x6c, 0x6d, 0x6f, 0,
0x6f, 0x6c, 0x6f, 0x72, 0,
0x6f, 0x6c, 0x76, 0x69, 0x64, 0x6f, 0,
0x6f, 0x6d, 0x62, 0x6c, 0x69, 0x67, 0x6f, 0,
0x6f, 0x6e, 0x64, 0x61, 0,
0x6f, 0x6e, 0x7a, 0x61, 0,
0x6f, 0x70, 0x61, 0x63, 0x6f, 0,
0x6f, 0x70, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6f, 0xcc, 0x81, 0x70, 0x65, 0x72, 0x61, 0,
0x6f, 0x70, 0x69, 0x6e, 0x61, 0x72, 0,
0x6f, 0x70, 0x6f, 0x6e, 0x65, 0x72, 0,
0x6f, 0x70, 0x74, 0x61, 0x72, 0,
0x6f, 0xcc, 0x81, 0x70, 0x74, 0x69, 0x63, 0x61, 0,
0x6f, 0x70, 0x75, 0x65, 0x73, 0x74, 0x6f, 0,
0x6f, 0x72, 0x61, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x6f, 0x72, 0x61, 0x64, 0x6f, 0x72, 0,
0x6f, 0x72, 0x61, 0x6c, 0,
0x6f, 0xcc, 0x81, 0x72, 0x62, 0x69, 0x74, 0x61, 0,
0x6f, 0x72, 0x63, 0x61, 0,
0x6f, 0x72, 0x64, 0x65, 0x6e, 0,
0x6f, 0x72, 0x65, 0x6a, 0x61, 0,
0x6f, 0xcc, 0x81, 0x72, 0x67, 0x61, 0x6e, 0x6f, 0,
0x6f, 0x72, 0x67, 0x69, 0xcc, 0x81, 0x61, 0,
0x6f, 0x72, 0x67, 0x75, 0x6c, 0x6c, 0x6f, 0,
0x6f, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x65, 0,
0x6f, 0x72, 0x69, 0x67, 0x65, 0x6e, 0,
0x6f, 0x72, 0x69, 0x6c, 0x6c, 0x61, 0,
0x6f, 0x72, 0x6f, 0,
0x6f, 0x72, 0x71, 0x75, 0x65, 0x73, 0x74, 0x61, 0,
0x6f, 0x72, 0x75, 0x67, 0x61, 0,
0x6f, 0x73, 0x61, 0x64, 0x69, 0xcc, 0x81, 0x61, 0,
0x6f, 0x73, 0x63, 0x75, 0x72, 0x6f, 0,
0x6f, 0x73, 0x65, 0x7a, 0x6e, 0x6f, 0,
0x6f, 0x73, 0x6f, 0,
0x6f, 0x73, 0x74, 0x72, 0x61, 0,
0x6f, 0x74, 0x6f, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x6f, 0x74, 0x72, 0x6f, 0,
0x6f, 0x76, 0x65, 0x6a, 0x61, 0,
0x6f, 0xcc, 0x81, 0x76, 0x75, 0x6c, 0x6f, 0,
0x6f, 0xcc, 0x81, 0x78, 0x69, 0x64, 0x6f, 0,
0x6f, 0x78, 0x69, 0xcc, 0x81, 0x67, 0x65, 0x6e, 0x6f, 0,
0x6f, 0x79, 0x65, 0x6e, 0x74, 0x65, 0,
0x6f, 0x7a, 0x6f, 0x6e, 0x6f, 0,
0x70, 0x61, 0x63, 0x74, 0x6f, 0,
0x70, 0x61, 0x64, 0x72, 0x65, 0,
0x70, 0x61, 0x65, 0x6c, 0x6c, 0x61, 0,
0x70, 0x61, 0xcc, 0x81, 0x67, 0x69, 0x6e, 0x61, 0,
0x70, 0x61, 0x67, 0x6f, 0,
0x70, 0x61, 0x69, 0xcc, 0x81, 0x73, 0,
0x70, 0x61, 0xcc, 0x81, 0x6a, 0x61, 0x72, 0x6f, 0,
0x70, 0x61, 0x6c, 0x61, 0x62, 0x72, 0x61, 0,
0x70, 0x61, 0x6c, 0x63, 0x6f, 0,
0x70, 0x61, 0x6c, 0x65, 0x74, 0x61, 0,
0x70, 0x61, 0xcc, 0x81, 0x6c, 0x69, 0x64, 0x6f, 0,
0x70, 0x61, 0x6c, 0x6d, 0x61, 0,
0x70, 0x61, 0x6c, 0x6f, 0x6d, 0x61, 0,
0x70, 0x61, 0x6c, 0x70, 0x61, 0x72, 0,
0x70, 0x61, 0x6e, 0,
0x70, 0x61, 0x6e, 0x61, 0x6c, 0,
0x70, 0x61, 0xcc, 0x81, 0x6e, 0x69, 0x63, 0x6f, 0,
0x70, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x61, 0,
0x70, 0x61, 0x6e, 0xcc, 0x83, 0x75, 0x65, 0x6c, 0x6f, 0,
0x70, 0x61, 0x70, 0x61, 0xcc, 0x81, 0,
0x70, 0x61, 0x70, 0x65, 0x6c, 0,
0x70, 0x61, 0x70, 0x69, 0x6c, 0x6c, 0x61, 0,
0x70, 0x61, 0x71, 0x75, 0x65, 0x74, 0x65, 0,
0x70, 0x61, 0x72, 0x61, 0x72, 0,
0x70, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x61, 0,
0x70, 0x61, 0x72, 0x65, 0x64, 0,
0x70, 0x61, 0x72, 0x69, 0x72, 0,
0x70, 0x61, 0x72, 0x6f, 0,
0x70, 0x61, 0xcc, 0x81, 0x72, 0x70, 0x61, 0x64, 0x6f, 0,
0x70, 0x61, 0x72, 0x71, 0x75, 0x65, 0,
0x70, 0x61, 0xcc, 0x81, 0x72, 0x72, 0x61, 0x66, 0x6f, 0,
0x70, 0x61, 0x72, 0x74, 0x65, 0,
0x70, 0x61, 0x73, 0x61, 0x72, 0,
0x70, 0x61, 0x73, 0x65, 0x6f, 0,
0x70, 0x61, 0x73, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x61, 0x73, 0x6f, 0,
0x70, 0x61, 0x73, 0x74, 0x61, 0,
0x70, 0x61, 0x74, 0x61, 0,
0x70, 0x61, 0x74, 0x69, 0x6f, 0,
0x70, 0x61, 0x74, 0x72, 0x69, 0x61, 0,
0x70, 0x61, 0x75, 0x73, 0x61, 0,
0x70, 0x61, 0x75, 0x74, 0x61, 0,
0x70, 0x61, 0x76, 0x6f, 0,
0x70, 0x61, 0x79, 0x61, 0x73, 0x6f, 0,
0x70, 0x65, 0x61, 0x74, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x65, 0x63, 0x61, 0x64, 0x6f, 0,
0x70, 0x65, 0x63, 0x65, 0x72, 0x61, 0,
0x70, 0x65, 0x63, 0x68, 0x6f, 0,
0x70, 0x65, 0x64, 0x61, 0x6c, 0,
0x70, 0x65, 0x64, 0x69, 0x72, 0,
0x70, 0x65, 0x67, 0x61, 0x72, 0,
0x70, 0x65, 0x69, 0x6e, 0x65, 0,
0x70, 0x65, 0x6c, 0x61, 0x72, 0,
0x70, 0x65, 0x6c, 0x64, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x70, 0x65, 0x6c, 0x65, 0x61, 0,
0x70, 0x65, 0x6c, 0x69, 0x67, 0x72, 0x6f, 0,
0x70, 0x65, 0x6c, 0x6c, 0x65, 0x6a, 0x6f, 0,
0x70, 0x65, 0x6c, 0x6f, 0,
0x70, 0x65, 0x6c, 0x75, 0x63, 0x61, 0,
0x70, 0x65, 0x6e, 0x61, 0,
0x70, 0x65, 0x6e, 0x73, 0x61, 0x72, 0,
0x70, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x65, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x65, 0x6f, 0x72, 0,
0x70, 0x65, 0x70, 0x69, 0x6e, 0x6f, 0,
0x70, 0x65, 0x71, 0x75, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x70, 0x65, 0x72, 0x61, 0,
0x70, 0x65, 0x72, 0x63, 0x68, 0x61, 0,
0x70, 0x65, 0x72, 0x64, 0x65, 0x72, 0,
0x70, 0x65, 0x72, 0x65, 0x7a, 0x61, 0,
0x70, 0x65, 0x72, 0x66, 0x69, 0x6c, 0,
0x70, 0x65, 0x72, 0x69, 0x63, 0x6f, 0,
0x70, 0x65, 0x72, 0x6c, 0x61, 0,
0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x6f, 0,
0x70, 0x65, 0x72, 0x72, 0x6f, 0,
0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0,
0x70, 0x65, 0x73, 0x61, 0,
0x70, 0x65, 0x73, 0x63, 0x61, 0,
0x70, 0x65, 0xcc, 0x81, 0x73, 0x69, 0x6d, 0x6f, 0,
0x70, 0x65, 0x73, 0x74, 0x61, 0x6e, 0xcc, 0x83, 0x61, 0,
0x70, 0x65, 0xcc, 0x81, 0x74, 0x61, 0x6c, 0x6f, 0,
0x70, 0x65, 0x74, 0x72, 0x6f, 0xcc, 0x81, 0x6c, 0x65, 0x6f, 0,
0x70, 0x65, 0x7a, 0,
0x70, 0x65, 0x7a, 0x75, 0x6e, 0xcc, 0x83, 0x61, 0,
0x70, 0x69, 0x63, 0x61, 0x72, 0,
0x70, 0x69, 0x63, 0x68, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x69, 0x65, 0,
0x70, 0x69, 0x65, 0x64, 0x72, 0x61, 0,
0x70, 0x69, 0x65, 0x72, 0x6e, 0x61, 0,
0x70, 0x69, 0x65, 0x7a, 0x61, 0,
0x70, 0x69, 0x6a, 0x61, 0x6d, 0x61, 0,
0x70, 0x69, 0x6c, 0x61, 0x72, 0,
0x70, 0x69, 0x6c, 0x6f, 0x74, 0x6f, 0,
0x70, 0x69, 0x6d, 0x69, 0x65, 0x6e, 0x74, 0x61, 0,
0x70, 0x69, 0x6e, 0x6f, 0,
0x70, 0x69, 0x6e, 0x74, 0x6f, 0x72, 0,
0x70, 0x69, 0x6e, 0x7a, 0x61, 0,
0x70, 0x69, 0x6e, 0xcc, 0x83, 0x61, 0,
0x70, 0x69, 0x6f, 0x6a, 0x6f, 0,
0x70, 0x69, 0x70, 0x61, 0,
0x70, 0x69, 0x72, 0x61, 0x74, 0x61, 0,
0x70, 0x69, 0x73, 0x61, 0x72, 0,
0x70, 0x69, 0x73, 0x63, 0x69, 0x6e, 0x61, 0,
0x70, 0x69, 0x73, 0x6f, 0,
0x70, 0x69, 0x73, 0x74, 0x61, 0,
0x70, 0x69, 0x74, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x69, 0x7a, 0x63, 0x61, 0,
0x70, 0x6c, 0x61, 0x63, 0x61, 0,
0x70, 0x6c, 0x61, 0x6e, 0,
0x70, 0x6c, 0x61, 0x74, 0x61, 0,
0x70, 0x6c, 0x61, 0x79, 0x61, 0,
0x70, 0x6c, 0x61, 0x7a, 0x61, 0,
0x70, 0x6c, 0x65, 0x69, 0x74, 0x6f, 0,
0x70, 0x6c, 0x65, 0x6e, 0x6f, 0,
0x70, 0x6c, 0x6f, 0x6d, 0x6f, 0,
0x70, 0x6c, 0x75, 0x6d, 0x61, 0,
0x70, 0x6c, 0x75, 0x72, 0x61, 0x6c, 0,
0x70, 0x6f, 0x62, 0x72, 0x65, 0,
0x70, 0x6f, 0x63, 0x6f, 0,
0x70, 0x6f, 0x64, 0x65, 0x72, 0,
0x70, 0x6f, 0x64, 0x69, 0x6f, 0,
0x70, 0x6f, 0x65, 0x6d, 0x61, 0,
0x70, 0x6f, 0x65, 0x73, 0x69, 0xcc, 0x81, 0x61, 0,
0x70, 0x6f, 0x65, 0x74, 0x61, 0,
0x70, 0x6f, 0x6c, 0x65, 0x6e, 0,
0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0xcc, 0x81, 0x61, 0,
0x70, 0x6f, 0x6c, 0x6c, 0x6f, 0,
0x70, 0x6f, 0x6c, 0x76, 0x6f, 0,
0x70, 0x6f, 0x6d, 0x61, 0x64, 0x61, 0,
0x70, 0x6f, 0x6d, 0x65, 0x6c, 0x6f, 0,
0x70, 0x6f, 0x6d, 0x6f, 0,
0x70, 0x6f, 0x6d, 0x70, 0x61, 0,
0x70, 0x6f, 0x6e, 0x65, 0x72, 0,
0x70, 0x6f, 0x72, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x6f, 0x72, 0x74, 0x61, 0x6c, 0,
0x70, 0x6f, 0x73, 0x61, 0x64, 0x61, 0,
0x70, 0x6f, 0x73, 0x65, 0x65, 0x72, 0,
0x70, 0x6f, 0x73, 0x69, 0x62, 0x6c, 0x65, 0,
0x70, 0x6f, 0x73, 0x74, 0x65, 0,
0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x61, 0,
0x70, 0x6f, 0x74, 0x72, 0x6f, 0,
0x70, 0x6f, 0x7a, 0x6f, 0,
0x70, 0x72, 0x61, 0x64, 0x6f, 0,
0x70, 0x72, 0x65, 0x63, 0x6f, 0x7a, 0,
0x70, 0x72, 0x65, 0x67, 0x75, 0x6e, 0x74, 0x61, 0,
0x70, 0x72, 0x65, 0x6d, 0x69, 0x6f, 0,
0x70, 0x72, 0x65, 0x6e, 0x73, 0x61, 0,
0x70, 0x72, 0x65, 0x73, 0x6f, 0,
0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0,
0x70, 0x72, 0x69, 0x6d, 0x6f, 0,
0x70, 0x72, 0x69, 0xcc, 0x81, 0x6e, 0x63, 0x69, 0x70, 0x65, 0,
0x70, 0x72, 0x69, 0x73, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x72, 0x69, 0x76, 0x61, 0x72, 0,
0x70, 0x72, 0x6f, 0x61, 0,
0x70, 0x72, 0x6f, 0x62, 0x61, 0x72, 0,
0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x6f, 0,
0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x6f, 0,
0x70, 0x72, 0x6f, 0x65, 0x7a, 0x61, 0,
0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x6f, 0x72, 0,
0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x61, 0,
0x70, 0x72, 0x6f, 0x6c, 0x65, 0,
0x70, 0x72, 0x6f, 0x6d, 0x65, 0x73, 0x61, 0,
0x70, 0x72, 0x6f, 0x6e, 0x74, 0x6f, 0,
0x70, 0x72, 0x6f, 0x70, 0x69, 0x6f, 0,
0x70, 0x72, 0x6f, 0xcc, 0x81, 0x78, 0x69, 0x6d, 0x6f, 0,
0x70, 0x72, 0x75, 0x65, 0x62, 0x61, 0,
0x70, 0x75, 0xcc, 0x81, 0x62, 0x6c, 0x69, 0x63, 0x6f, 0,
0x70, 0x75, 0x63, 0x68, 0x65, 0x72, 0x6f, 0,
0x70, 0x75, 0x64, 0x6f, 0x72, 0,
0x70, 0x75, 0x65, 0x62, 0x6c, 0x6f, 0,
0x70, 0x75, 0x65, 0x72, 0x74, 0x61, 0,
0x70, 0x75, 0x65, 0x73, 0x74, 0x6f, 0,
0x70, 0x75, 0x6c, 0x67, 0x61, 0,
0x70, 0x75, 0x6c, 0x69, 0x72, 0,
0x70, 0x75, 0x6c, 0x6d, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x70, 0x75, 0x6c, 0x70, 0x6f, 0,
0x70, 0x75, 0x6c, 0x73, 0x6f, 0,
0x70, 0x75, 0x6d, 0x61, 0,
0x70, 0x75, 0x6e, 0x74, 0x6f, 0,
0x70, 0x75, 0x6e, 0xcc, 0x83, 0x61, 0x6c, 0,
0x70, 0x75, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x70, 0x75, 0x70, 0x61, 0,
0x70, 0x75, 0x70, 0x69, 0x6c, 0x61, 0,
0x70, 0x75, 0x72, 0x65, 0xcc, 0x81, 0,
0x71, 0x75, 0x65, 0x64, 0x61, 0x72, 0,
0x71, 0x75, 0x65, 0x6a, 0x61, 0,
0x71, 0x75, 0x65, 0x6d, 0x61, 0x72, 0,
0x71, 0x75, 0x65, 0x72, 0x65, 0x72, 0,
0x71, 0x75, 0x65, 0x73, 0x6f, 0,
0x71, 0x75, 0x69, 0x65, 0x74, 0x6f, 0,
0x71, 0x75, 0x69, 0xcc, 0x81, 0x6d, 0x69, 0x63, 0x61, 0,
0x71, 0x75, 0x69, 0x6e, 0x63, 0x65, 0,
0x71, 0x75, 0x69, 0x74, 0x61, 0x72, 0,
0x72, 0x61, 0xcc, 0x81, 0x62, 0x61, 0x6e, 0x6f, 0,
0x72, 0x61, 0x62, 0x69, 0x61, 0,
0x72, 0x61, 0x62, 0x6f, 0,
0x72, 0x61, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x72, 0x61, 0x64, 0x69, 0x63, 0x61, 0x6c, 0,
0x72, 0x61, 0x69, 0xcc, 0x81, 0x7a, 0,
0x72, 0x61, 0x6d, 0x61, 0,
0x72, 0x61, 0x6d, 0x70, 0x61, 0,
0x72, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0,
0x72, 0x61, 0x6e, 0x67, 0x6f, 0,
0x72, 0x61, 0x70, 0x61, 0x7a, 0,
0x72, 0x61, 0xcc, 0x81, 0x70, 0x69, 0x64, 0x6f, 0,
0x72, 0x61, 0x70, 0x74, 0x6f, 0,
0x72, 0x61, 0x73, 0x67, 0x6f, 0,
0x72, 0x61, 0x73, 0x70, 0x61, 0,
0x72, 0x61, 0x74, 0x6f, 0,
0x72, 0x61, 0x79, 0x6f, 0,
0x72, 0x61, 0x7a, 0x61, 0,
0x72, 0x61, 0x7a, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x72, 0x65, 0x61, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x72, 0x65, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x64, 0,
0x72, 0x65, 0x62, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x72, 0x65, 0x62, 0x6f, 0x74, 0x65, 0,
0x72, 0x65, 0x63, 0x61, 0x65, 0x72, 0,
0x72, 0x65, 0x63, 0x65, 0x74, 0x61, 0,
0x72, 0x65, 0x63, 0x68, 0x61, 0x7a, 0x6f, 0,
0x72, 0x65, 0x63, 0x6f, 0x67, 0x65, 0x72, 0,
0x72, 0x65, 0x63, 0x72, 0x65, 0x6f, 0,
0x72, 0x65, 0x63, 0x74, 0x6f, 0,
0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x6f, 0,
0x72, 0x65, 0x64, 0,
0x72, 0x65, 0x64, 0x6f, 0x6e, 0x64, 0x6f, 0,
0x72, 0x65, 0x64, 0x75, 0x63, 0x69, 0x72, 0,
0x72, 0x65, 0x66, 0x6c, 0x65, 0x6a, 0x6f, 0,
0x72, 0x65, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0,
0x72, 0x65, 0x66, 0x72, 0x61, 0xcc, 0x81, 0x6e, 0,
0x72, 0x65, 0x66, 0x75, 0x67, 0x69, 0x6f, 0,
0x72, 0x65, 0x67, 0x61, 0x6c, 0x6f, 0,
0x72, 0x65, 0x67, 0x69, 0x72, 0,
0x72, 0x65, 0x67, 0x6c, 0x61, 0,
0x72, 0x65, 0x67, 0x72, 0x65, 0x73, 0x6f, 0,
0x72, 0x65, 0x68, 0x65, 0xcc, 0x81, 0x6e, 0,
0x72, 0x65, 0x69, 0x6e, 0x6f, 0,
0x72, 0x65, 0x69, 0xcc, 0x81, 0x72, 0,
0x72, 0x65, 0x6a, 0x61, 0,
0x72, 0x65, 0x6c, 0x61, 0x74, 0x6f, 0,
0x72, 0x65, 0x6c, 0x65, 0x76, 0x6f, 0,
0x72, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0,
0x72, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x6f, 0,
0x72, 0x65, 0x6c, 0x6f, 0x6a, 0,
0x72, 0x65, 0x6d, 0x61, 0x72, 0,
0x72, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x6f, 0,
0x72, 0x65, 0x6d, 0x6f, 0,
0x72, 0x65, 0x6e, 0x63, 0x6f, 0x72, 0,
0x72, 0x65, 0x6e, 0x64, 0x69, 0x72, 0,
0x72, 0x65, 0x6e, 0x74, 0x61, 0,
0x72, 0x65, 0x70, 0x61, 0x72, 0x74, 0x6f, 0,
0x72, 0x65, 0x70, 0x65, 0x74, 0x69, 0x72, 0,
0x72, 0x65, 0x70, 0x6f, 0x73, 0x6f, 0,
0x72, 0x65, 0x70, 0x74, 0x69, 0x6c, 0,
0x72, 0x65, 0x73, 0,
0x72, 0x65, 0x73, 0x63, 0x61, 0x74, 0x65, 0,
0x72, 0x65, 0x73, 0x69, 0x6e, 0x61, 0,
0x72, 0x65, 0x73, 0x70, 0x65, 0x74, 0x6f, 0,
0x72, 0x65, 0x73, 0x74, 0x6f, 0,
0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x6e, 0,
0x72, 0x65, 0x74, 0x69, 0x72, 0x6f, 0,
0x72, 0x65, 0x74, 0x6f, 0x72, 0x6e, 0x6f, 0,
0x72, 0x65, 0x74, 0x72, 0x61, 0x74, 0x6f, 0,
0x72, 0x65, 0x75, 0x6e, 0x69, 0x72, 0,
0x72, 0x65, 0x76, 0x65, 0xcc, 0x81, 0x73, 0,
0x72, 0x65, 0x76, 0x69, 0x73, 0x74, 0x61, 0,
0x72, 0x65, 0x79, 0,
0x72, 0x65, 0x7a, 0x61, 0x72, 0,
0x72, 0x69, 0x63, 0x6f, 0,
0x72, 0x69, 0x65, 0x67, 0x6f, 0,
0x72, 0x69, 0x65, 0x6e, 0x64, 0x61, 0,
0x72, 0x69, 0x65, 0x73, 0x67, 0x6f, 0,
0x72, 0x69, 0x66, 0x61, 0,
0x72, 0x69, 0xcc, 0x81, 0x67, 0x69, 0x64, 0x6f, 0,
0x72, 0x69, 0x67, 0x6f, 0x72, 0,
0x72, 0x69, 0x6e, 0x63, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x72, 0x69, 0x6e, 0xcc, 0x83, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x72, 0x69, 0xcc, 0x81, 0x6f, 0,
0x72, 0x69, 0x71, 0x75, 0x65, 0x7a, 0x61, 0,
0x72, 0x69, 0x73, 0x61, 0,
0x72, 0x69, 0x74, 0x6d, 0x6f, 0,
0x72, 0x69, 0x74, 0x6f, 0,
0x72, 0x69, 0x7a, 0x6f, 0,
0x72, 0x6f, 0x62, 0x6c, 0x65, 0,
0x72, 0x6f, 0x63, 0x65, 0,
0x72, 0x6f, 0x63, 0x69, 0x61, 0x72, 0,
0x72, 0x6f, 0x64, 0x61, 0x72, 0,
0x72, 0x6f, 0x64, 0x65, 0x6f, 0,
0x72, 0x6f, 0x64, 0x69, 0x6c, 0x6c, 0x61, 0,
0x72, 0x6f, 0x65, 0x72, 0,
0x72, 0x6f, 0x6a, 0x69, 0x7a, 0x6f, 0,
0x72, 0x6f, 0x6a, 0x6f, 0,
0x72, 0x6f, 0x6d, 0x65, 0x72, 0x6f, 0,
0x72, 0x6f, 0x6d, 0x70, 0x65, 0x72, 0,
0x72, 0x6f, 0x6e, 0,
0x72, 0x6f, 0x6e, 0x63, 0x6f, 0,
0x72, 0x6f, 0x6e, 0x64, 0x61, 0,
0x72, 0x6f, 0x70, 0x61, 0,
0x72, 0x6f, 0x70, 0x65, 0x72, 0x6f, 0,
0x72, 0x6f, 0x73, 0x61, 0,
0x72, 0x6f, 0x73, 0x63, 0x61, 0,
0x72, 0x6f, 0x73, 0x74, 0x72, 0x6f, 0,
0x72, 0x6f, 0x74, 0x61, 0x72, 0,
0x72, 0x75, 0x62, 0x69, 0xcc, 0x81, 0,
0x72, 0x75, 0x62, 0x6f, 0x72, 0,
0x72, 0x75, 0x64, 0x6f, 0,
0x72, 0x75, 0x65, 0x64, 0x61, 0,
0x72, 0x75, 0x67, 0x69, 0x72, 0,
0x72, 0x75, 0x69, 0x64, 0x6f, 0,
0x72, 0x75, 0x69, 0x6e, 0x61, 0,
0x72, 0x75, 0x6c, 0x65, 0x74, 0x61, 0,
0x72, 0x75, 0x6c, 0x6f, 0,
0x72, 0x75, 0x6d, 0x62, 0x6f, 0,
0x72, 0x75, 0x6d, 0x6f, 0x72, 0,
0x72, 0x75, 0x70, 0x74, 0x75, 0x72, 0x61, 0,
0x72, 0x75, 0x74, 0x61, 0,
0x72, 0x75, 0x74, 0x69, 0x6e, 0x61, 0,
0x73, 0x61, 0xcc, 0x81, 0x62, 0x61, 0x64, 0x6f, 0,
0x73, 0x61, 0x62, 0x65, 0x72, 0,
0x73, 0x61, 0x62, 0x69, 0x6f, 0,
0x73, 0x61, 0x62, 0x6c, 0x65, 0,
0x73, 0x61, 0x63, 0x61, 0x72, 0,
0x73, 0x61, 0x67, 0x61, 0x7a, 0,
0x73, 0x61, 0x67, 0x72, 0x61, 0x64, 0x6f, 0,
0x73, 0x61, 0x6c, 0x61, 0,
0x73, 0x61, 0x6c, 0x64, 0x6f, 0,
0x73, 0x61, 0x6c, 0x65, 0x72, 0x6f, 0,
0x73, 0x61, 0x6c, 0x69, 0x72, 0,
0x73, 0x61, 0x6c, 0x6d, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x61, 0x6c, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x61, 0x6c, 0x73, 0x61, 0,
0x73, 0x61, 0x6c, 0x74, 0x6f, 0,
0x73, 0x61, 0x6c, 0x75, 0x64, 0,
0x73, 0x61, 0x6c, 0x76, 0x61, 0x72, 0,
0x73, 0x61, 0x6d, 0x62, 0x61, 0,
0x73, 0x61, 0x6e, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x61, 0x6e, 0x64, 0x69, 0xcc, 0x81, 0x61, 0,
0x73, 0x61, 0x6e, 0x65, 0x61, 0x72, 0,
0x73, 0x61, 0x6e, 0x67, 0x72, 0x65, 0,
0x73, 0x61, 0x6e, 0x69, 0x64, 0x61, 0x64, 0,
0x73, 0x61, 0x6e, 0x6f, 0,
0x73, 0x61, 0x6e, 0x74, 0x6f, 0,
0x73, 0x61, 0x70, 0x6f, 0,
0x73, 0x61, 0x71, 0x75, 0x65, 0,
0x73, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0,
0x73, 0x61, 0x72, 0x74, 0x65, 0xcc, 0x81, 0x6e, 0,
0x73, 0x61, 0x73, 0x74, 0x72, 0x65, 0,
0x73, 0x61, 0x74, 0x61, 0xcc, 0x81, 0x6e, 0,
0x73, 0x61, 0x75, 0x6e, 0x61, 0,
0x73, 0x61, 0x78, 0x6f, 0x66, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x65, 0x63, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x65, 0x63, 0x6f, 0,
0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x6f, 0,
0x73, 0x65, 0x63, 0x74, 0x61, 0,
0x73, 0x65, 0x64, 0,
0x73, 0x65, 0x67, 0x75, 0x69, 0x72, 0,
0x73, 0x65, 0x69, 0x73, 0,
0x73, 0x65, 0x6c, 0x6c, 0x6f, 0,
0x73, 0x65, 0x6c, 0x76, 0x61, 0,
0x73, 0x65, 0x6d, 0x61, 0x6e, 0x61, 0,
0x73, 0x65, 0x6d, 0x69, 0x6c, 0x6c, 0x61, 0,
0x73, 0x65, 0x6e, 0x64, 0x61, 0,
0x73, 0x65, 0x6e, 0x73, 0x6f, 0x72, 0,
0x73, 0x65, 0x6e, 0xcc, 0x83, 0x61, 0x6c, 0,
0x73, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0x72, 0,
0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x72, 0,
0x73, 0x65, 0x70, 0x69, 0x61, 0,
0x73, 0x65, 0x71, 0x75, 0x69, 0xcc, 0x81, 0x61, 0,
0x73, 0x65, 0x72, 0,
0x73, 0x65, 0x72, 0x69, 0x65, 0,
0x73, 0x65, 0x72, 0x6d, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x65, 0x72, 0x76, 0x69, 0x72, 0,
0x73, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0,
0x73, 0x65, 0x73, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x65, 0x74, 0x61, 0,
0x73, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x61, 0,
0x73, 0x65, 0x76, 0x65, 0x72, 0x6f, 0,
0x73, 0x65, 0x78, 0x6f, 0,
0x73, 0x65, 0x78, 0x74, 0x6f, 0,
0x73, 0x69, 0x64, 0x72, 0x61, 0,
0x73, 0x69, 0x65, 0x73, 0x74, 0x61, 0,
0x73, 0x69, 0x65, 0x74, 0x65, 0,
0x73, 0x69, 0x67, 0x6c, 0x6f, 0,
0x73, 0x69, 0x67, 0x6e, 0x6f, 0,
0x73, 0x69, 0xcc, 0x81, 0x6c, 0x61, 0x62, 0x61, 0,
0x73, 0x69, 0x6c, 0x62, 0x61, 0x72, 0,
0x73, 0x69, 0x6c, 0x65, 0x6e, 0x63, 0x69, 0x6f, 0,
0x73, 0x69, 0x6c, 0x6c, 0x61, 0,
0x73, 0x69, 0xcc, 0x81, 0x6d, 0x62, 0x6f, 0x6c, 0x6f, 0,
0x73, 0x69, 0x6d, 0x69, 0x6f, 0,
0x73, 0x69, 0x72, 0x65, 0x6e, 0x61, 0,
0x73, 0x69, 0x73, 0x74, 0x65, 0x6d, 0x61, 0,
0x73, 0x69, 0x74, 0x69, 0x6f, 0,
0x73, 0x69, 0x74, 0x75, 0x61, 0x72, 0,
0x73, 0x6f, 0x62, 0x72, 0x65, 0,
0x73, 0x6f, 0x63, 0x69, 0x6f, 0,
0x73, 0x6f, 0x64, 0x69, 0x6f, 0,
0x73, 0x6f, 0x6c, 0,
0x73, 0x6f, 0x6c, 0x61, 0x70, 0x61, 0,
0x73, 0x6f, 0x6c, 0x64, 0x61, 0x64, 0x6f, 0,
0x73, 0x6f, 0x6c, 0x65, 0x64, 0x61, 0x64, 0,
0x73, 0x6f, 0xcc, 0x81, 0x6c, 0x69, 0x64, 0x6f, 0,
0x73, 0x6f, 0x6c, 0x74, 0x61, 0x72, 0,
0x73, 0x6f, 0x6c, 0x75, 0x63, 0x69, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x73, 0x6f, 0x6d, 0x62, 0x72, 0x61, 0,
0x73, 0x6f, 0x6e, 0x64, 0x65, 0x6f, 0,
0x73, 0x6f, 0x6e, 0x69, 0x64, 0x6f, 0,
0x73, 0x6f, 0x6e, 0x6f, 0x72, 0x6f, 0,
0x73, 0x6f, 0x6e, 0x72, 0x69, 0x73, 0x61, 0,
0x73, 0x6f, 0x70, 0x61, 0,
0x73, 0x6f, 0x70, 0x6c, 0x61, 0x72, 0,
0x73, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x65, 0,
0x73, 0x6f, 0x72, 0x64, 0x6f, 0,
0x73, 0x6f, 0x72, 0x70, 0x72, 0x65, 0x73, 0x61, 0,
0x73, 0x6f, 0x72, 0x74, 0x65, 0x6f, 0,
0x73, 0x6f, 0x73, 0x74, 0x65, 0xcc, 0x81, 0x6e, 0,
0x73, 0x6f, 0xcc, 0x81, 0x74, 0x61, 0x6e, 0x6f, 0,
0x73, 0x75, 0x61, 0x76, 0x65, 0,
0x73, 0x75, 0x62, 0x69, 0x72, 0,
0x73, 0x75, 0x63, 0x65, 0x73, 0x6f, 0,
0x73, 0x75, 0x64, 0x6f, 0x72, 0,
0x73, 0x75, 0x65, 0x67, 0x72, 0x61, 0,
0x73, 0x75, 0x65, 0x6c, 0x6f, 0,
0x73, 0x75, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x73, 0x75, 0x65, 0x72, 0x74, 0x65, 0,
0x73, 0x75, 0x66, 0x72, 0x69, 0x72, 0,
0x73, 0x75, 0x6a, 0x65, 0x74, 0x6f, 0,
0x73, 0x75, 0x6c, 0x74, 0x61, 0xcc, 0x81, 0x6e, 0,
0x73, 0x75, 0x6d, 0x61, 0x72, 0,
0x73, 0x75, 0x70, 0x65, 0x72, 0x61, 0x72, 0,
0x73, 0x75, 0x70, 0x6c, 0x69, 0x72, 0,
0x73, 0x75, 0x70, 0x6f, 0x6e, 0x65, 0x72, 0,
0x73, 0x75, 0x70, 0x72, 0x65, 0x6d, 0x6f, 0,
0x73, 0x75, 0x72, 0,
0x73, 0x75, 0x72, 0x63, 0x6f, 0,
0x73, 0x75, 0x72, 0x65, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x73, 0x75, 0x72, 0x67, 0x69, 0x72, 0,
0x73, 0x75, 0x73, 0x74, 0x6f, 0,
0x73, 0x75, 0x74, 0x69, 0x6c, 0,
0x74, 0x61, 0x62, 0x61, 0x63, 0x6f, 0,
0x74, 0x61, 0x62, 0x69, 0x71, 0x75, 0x65, 0,
0x74, 0x61, 0x62, 0x6c, 0x61, 0,
0x74, 0x61, 0x62, 0x75, 0xcc, 0x81, 0,
0x74, 0x61, 0x63, 0x6f, 0,
0x74, 0x61, 0x63, 0x74, 0x6f, 0,
0x74, 0x61, 0x6a, 0x6f, 0,
0x74, 0x61, 0x6c, 0x61, 0x72, 0,
0x74, 0x61, 0x6c, 0x63, 0x6f, 0,
0x74, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x6f, 0,
0x74, 0x61, 0x6c, 0x6c, 0x61, 0,
0x74, 0x61, 0x6c, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x74, 0x61, 0x6d, 0x61, 0x6e, 0xcc, 0x83, 0x6f, 0,
0x74, 0x61, 0x6d, 0x62, 0x6f, 0x72, 0,
0x74, 0x61, 0x6e, 0x67, 0x6f, 0,
0x74, 0x61, 0x6e, 0x71, 0x75, 0x65, 0,
0x74, 0x61, 0x70, 0x61, 0,
0x74, 0x61, 0x70, 0x65, 0x74, 0x65, 0,
0x74, 0x61, 0x70, 0x69, 0x61, 0,
0x74, 0x61, 0x70, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x74, 0x61, 0x71, 0x75, 0x69, 0x6c, 0x6c, 0x61, 0,
0x74, 0x61, 0x72, 0x64, 0x65, 0,
0x74, 0x61, 0x72, 0x65, 0x61, 0,
0x74, 0x61, 0x72, 0x69, 0x66, 0x61, 0,
0x74, 0x61, 0x72, 0x6a, 0x65, 0x74, 0x61, 0,
0x74, 0x61, 0x72, 0x6f, 0x74, 0,
0x74, 0x61, 0x72, 0x72, 0x6f, 0,
0x74, 0x61, 0x72, 0x74, 0x61, 0,
0x74, 0x61, 0x74, 0x75, 0x61, 0x6a, 0x65, 0,
0x74, 0x61, 0x75, 0x72, 0x6f, 0,
0x74, 0x61, 0x7a, 0x61, 0,
0x74, 0x61, 0x7a, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x74, 0x65, 0x61, 0x74, 0x72, 0x6f, 0,
0x74, 0x65, 0x63, 0x68, 0x6f, 0,
0x74, 0x65, 0x63, 0x6c, 0x61, 0,
0x74, 0x65, 0xcc, 0x81, 0x63, 0x6e, 0x69, 0x63, 0x61, 0,
0x74, 0x65, 0x6a, 0x61, 0x64, 0x6f, 0,
0x74, 0x65, 0x6a, 0x65, 0x72, 0,
0x74, 0x65, 0x6a, 0x69, 0x64, 0x6f, 0,
0x74, 0x65, 0x6c, 0x61, 0,
0x74, 0x65, 0x6c, 0x65, 0xcc, 0x81, 0x66, 0x6f, 0x6e, 0x6f, 0,
0x74, 0x65, 0x6d, 0x61, 0,
0x74, 0x65, 0x6d, 0x6f, 0x72, 0,
0x74, 0x65, 0x6d, 0x70, 0x6c, 0x6f, 0,
0x74, 0x65, 0x6e, 0x61, 0x7a, 0,
0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0,
0x74, 0x65, 0x6e, 0x65, 0x72, 0,
0x74, 0x65, 0x6e, 0x69, 0x73, 0,
0x74, 0x65, 0x6e, 0x73, 0x6f, 0,
0x74, 0x65, 0x6f, 0x72, 0x69, 0xcc, 0x81, 0x61, 0,
0x74, 0x65, 0x72, 0x61, 0x70, 0x69, 0x61, 0,
0x74, 0x65, 0x72, 0x63, 0x6f, 0,
0x74, 0x65, 0xcc, 0x81, 0x72, 0x6d, 0x69, 0x6e, 0x6f, 0,
0x74, 0x65, 0x72, 0x6e, 0x75, 0x72, 0x61, 0,
0x74, 0x65, 0x72, 0x72, 0x6f, 0x72, 0,
0x74, 0x65, 0x73, 0x69, 0x73, 0,
0x74, 0x65, 0x73, 0x6f, 0x72, 0x6f, 0,
0x74, 0x65, 0x73, 0x74, 0x69, 0x67, 0x6f, 0,
0x74, 0x65, 0x74, 0x65, 0x72, 0x61, 0,
0x74, 0x65, 0x78, 0x74, 0x6f, 0,
0x74, 0x65, 0x7a, 0,
0x74, 0x69, 0x62, 0x69, 0x6f, 0,
0x74, 0x69, 0x62, 0x75, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x74, 0x69, 0x65, 0x6d, 0x70, 0x6f, 0,
0x74, 0x69, 0x65, 0x6e, 0x64, 0x61, 0,
0x74, 0x69, 0x65, 0x72, 0x72, 0x61, 0,
0x74, 0x69, 0x65, 0x73, 0x6f, 0,
0x74, 0x69, 0x67, 0x72, 0x65, 0,
0x74, 0x69, 0x6a, 0x65, 0x72, 0x61, 0,
0x74, 0x69, 0x6c, 0x64, 0x65, 0,
0x74, 0x69, 0x6d, 0x62, 0x72, 0x65, 0,
0x74, 0x69, 0xcc, 0x81, 0x6d, 0x69, 0x64, 0x6f, 0,
0x74, 0x69, 0x6d, 0x6f, 0,
0x74, 0x69, 0x6e, 0x74, 0x61, 0,
0x74, 0x69, 0xcc, 0x81, 0x6f, 0,
0x74, 0x69, 0xcc, 0x81, 0x70, 0x69, 0x63, 0x6f, 0,
0x74, 0x69, 0x70, 0x6f, 0,
0x74, 0x69, 0x72, 0x61, 0,
0x74, 0x69, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x74, 0x69, 0x74, 0x61, 0xcc, 0x81, 0x6e, 0,
0x74, 0x69, 0xcc, 0x81, 0x74, 0x65, 0x72, 0x65, 0,
0x74, 0x69, 0xcc, 0x81, 0x74, 0x75, 0x6c, 0x6f, 0,
0x74, 0x69, 0x7a, 0x61, 0,
0x74, 0x6f, 0x61, 0x6c, 0x6c, 0x61, 0,
0x74, 0x6f, 0x62, 0x69, 0x6c, 0x6c, 0x6f, 0,
0x74, 0x6f, 0x63, 0x61, 0x72, 0,
0x74, 0x6f, 0x63, 0x69, 0x6e, 0x6f, 0,
0x74, 0x6f, 0x64, 0x6f, 0,
0x74, 0x6f, 0x67, 0x61, 0,
0x74, 0x6f, 0x6c, 0x64, 0x6f, 0,
0x74, 0x6f, 0x6d, 0x61, 0x72, 0,
0x74, 0x6f, 0x6e, 0x6f, 0,
0x74, 0x6f, 0x6e, 0x74, 0x6f, 0,
0x74, 0x6f, 0x70, 0x61, 0x72, 0,
0x74, 0x6f, 0x70, 0x65, 0,
0x74, 0x6f, 0x71, 0x75, 0x65, 0,
0x74, 0x6f, 0xcc, 0x81, 0x72, 0x61, 0x78, 0,
0x74, 0x6f, 0x72, 0x65, 0x72, 0x6f, 0,
0x74, 0x6f, 0x72, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0,
0x74, 0x6f, 0x72, 0x6e, 0x65, 0x6f, 0,
0x74, 0x6f, 0x72, 0x6f, 0,
0x74, 0x6f, 0x72, 0x70, 0x65, 0x64, 0x6f, 0,
0x74, 0x6f, 0x72, 0x72, 0x65, 0,
0x74, 0x6f, 0x72, 0x73, 0x6f, 0,
0x74, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x61, 0,
0x74, 0x6f, 0x73, 0,
0x74, 0x6f, 0x73, 0x63, 0x6f, 0,
0x74, 0x6f, 0x73, 0x65, 0x72, 0,
0x74, 0x6f, 0xcc, 0x81, 0x78, 0x69, 0x63, 0x6f, 0,
0x74, 0x72, 0x61, 0x62, 0x61, 0x6a, 0x6f, 0,
0x74, 0x72, 0x61, 0x63, 0x74, 0x6f, 0x72, 0,
0x74, 0x72, 0x61, 0x65, 0x72, 0,
0x74, 0x72, 0x61, 0xcc, 0x81, 0x66, 0x69, 0x63, 0x6f, 0,
0x74, 0x72, 0x61, 0x67, 0x6f, 0,
0x74, 0x72, 0x61, 0x6a, 0x65, 0,
0x74, 0x72, 0x61, 0x6d, 0x6f, 0,
0x74, 0x72, 0x61, 0x6e, 0x63, 0x65, 0,
0x74, 0x72, 0x61, 0x74, 0x6f, 0,
0x74, 0x72, 0x61, 0x75, 0x6d, 0x61, 0,
0x74, 0x72, 0x61, 0x7a, 0x61, 0x72, 0,
0x74, 0x72, 0x65, 0xcc, 0x81, 0x62, 0x6f, 0x6c, 0,
0x74, 0x72, 0x65, 0x67, 0x75, 0x61, 0,
0x74, 0x72, 0x65, 0x69, 0x6e, 0x74, 0x61, 0,
0x74, 0x72, 0x65, 0x6e, 0,
0x74, 0x72, 0x65, 0x70, 0x61, 0x72, 0,
0x74, 0x72, 0x65, 0x73, 0,
0x74, 0x72, 0x69, 0x62, 0x75, 0,
0x74, 0x72, 0x69, 0x67, 0x6f, 0,
0x74, 0x72, 0x69, 0x70, 0x61, 0,
0x74, 0x72, 0x69, 0x73, 0x74, 0x65, 0,
0x74, 0x72, 0x69, 0x75, 0x6e, 0x66, 0x6f, 0,
0x74, 0x72, 0x6f, 0x66, 0x65, 0x6f, 0,
0x74, 0x72, 0x6f, 0x6d, 0x70, 0x61, 0,
0x74, 0x72, 0x6f, 0x6e, 0x63, 0x6f, 0,
0x74, 0x72, 0x6f, 0x70, 0x61, 0,
0x74, 0x72, 0x6f, 0x74, 0x65, 0,
0x74, 0x72, 0x6f, 0x7a, 0x6f, 0,
0x74, 0x72, 0x75, 0x63, 0x6f, 0,
0x74, 0x72, 0x75, 0x65, 0x6e, 0x6f, 0,
0x74, 0x72, 0x75, 0x66, 0x61, 0,
0x74, 0x75, 0x62, 0x65, 0x72, 0x69, 0xcc, 0x81, 0x61, 0,
0x74, 0x75, 0x62, 0x6f, 0,
0x74, 0x75, 0x65, 0x72, 0x74, 0x6f, 0,
0x74, 0x75, 0x6d, 0x62, 0x61, 0,
0x74, 0x75, 0x6d, 0x6f, 0x72, 0,
0x74, 0x75, 0xcc, 0x81, 0x6e, 0x65, 0x6c, 0,
0x74, 0x75, 0xcc, 0x81, 0x6e, 0x69, 0x63, 0x61, 0,
0x74, 0x75, 0x72, 0x62, 0x69, 0x6e, 0x61, 0,
0x74, 0x75, 0x72, 0x69, 0x73, 0x6d, 0x6f, 0,
0x74, 0x75, 0x72, 0x6e, 0x6f, 0,
0x74, 0x75, 0x74, 0x6f, 0x72, 0,
0x75, 0x62, 0x69, 0x63, 0x61, 0x72, 0,
0x75, 0xcc, 0x81, 0x6c, 0x63, 0x65, 0x72, 0x61, 0,
0x75, 0x6d, 0x62, 0x72, 0x61, 0x6c, 0,
0x75, 0x6e, 0x69, 0x64, 0x61, 0x64, 0,
0x75, 0x6e, 0x69, 0x72, 0,
0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x6f, 0,
0x75, 0x6e, 0x6f, 0,
0x75, 0x6e, 0x74, 0x61, 0x72, 0,
0x75, 0x6e, 0xcc, 0x83, 0x61, 0,
0x75, 0x72, 0x62, 0x61, 0x6e, 0x6f, 0,
0x75, 0x72, 0x62, 0x65, 0,
0x75, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x65, 0,
0x75, 0x72, 0x6e, 0x61, 0,
0x75, 0x73, 0x61, 0x72, 0,
0x75, 0x73, 0x75, 0x61, 0x72, 0x69, 0x6f, 0,
0x75, 0xcc, 0x81, 0x74, 0x69, 0x6c, 0,
0x75, 0x74, 0x6f, 0x70, 0x69, 0xcc, 0x81, 0x61, 0,
0x75, 0x76, 0x61, 0,
0x76, 0x61, 0x63, 0x61, 0,
0x76, 0x61, 0x63, 0x69, 0xcc, 0x81, 0x6f, 0,
0x76, 0x61, 0x63, 0x75, 0x6e, 0x61, 0,
0x76, 0x61, 0x67, 0x61, 0x72, 0,
0x76, 0x61, 0x67, 0x6f, 0,
0x76, 0x61, 0x69, 0x6e, 0x61, 0,
0x76, 0x61, 0x6a, 0x69, 0x6c, 0x6c, 0x61, 0,
0x76, 0x61, 0x6c, 0x65, 0,
0x76, 0x61, 0xcc, 0x81, 0x6c, 0x69, 0x64, 0x6f, 0,
0x76, 0x61, 0x6c, 0x6c, 0x65, 0,
0x76, 0x61, 0x6c, 0x6f, 0x72, 0,
0x76, 0x61, 0xcc, 0x81, 0x6c, 0x76, 0x75, 0x6c, 0x61, 0,
0x76, 0x61, 0x6d, 0x70, 0x69, 0x72, 0x6f, 0,
0x76, 0x61, 0x72, 0x61, 0,
0x76, 0x61, 0x72, 0x69, 0x61, 0x72, 0,
0x76, 0x61, 0x72, 0x6f, 0xcc, 0x81, 0x6e, 0,
0x76, 0x61, 0x73, 0x6f, 0,
0x76, 0x65, 0x63, 0x69, 0x6e, 0x6f, 0,
0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0,
0x76, 0x65, 0x68, 0x69, 0xcc, 0x81, 0x63, 0x75, 0x6c, 0x6f, 0,
0x76, 0x65, 0x69, 0x6e, 0x74, 0x65, 0,
0x76, 0x65, 0x6a, 0x65, 0x7a, 0,
0x76, 0x65, 0x6c, 0x61, 0,
0x76, 0x65, 0x6c, 0x65, 0x72, 0x6f, 0,
0x76, 0x65, 0x6c, 0x6f, 0x7a, 0,
0x76, 0x65, 0x6e, 0x61, 0,
0x76, 0x65, 0x6e, 0x63, 0x65, 0x72, 0,
0x76, 0x65, 0x6e, 0x64, 0x61, 0,
0x76, 0x65, 0x6e, 0x65, 0x6e, 0x6f, 0,
0x76, 0x65, 0x6e, 0x67, 0x61, 0x72, 0,
0x76, 0x65, 0x6e, 0x69, 0x72, 0,
0x76, 0x65, 0x6e, 0x74, 0x61, 0,
0x76, 0x65, 0x6e, 0x75, 0x73, 0,
0x76, 0x65, 0x72, 0,
0x76, 0x65, 0x72, 0x61, 0x6e, 0x6f, 0,
0x76, 0x65, 0x72, 0x62, 0x6f, 0,
0x76, 0x65, 0x72, 0x64, 0x65, 0,
0x76, 0x65, 0x72, 0x65, 0x64, 0x61, 0,
0x76, 0x65, 0x72, 0x6a, 0x61, 0,
0x76, 0x65, 0x72, 0x73, 0x6f, 0,
0x76, 0x65, 0x72, 0x74, 0x65, 0x72, 0,
0x76, 0x69, 0xcc, 0x81, 0x61, 0,
0x76, 0x69, 0x61, 0x6a, 0x65, 0,
0x76, 0x69, 0x62, 0x72, 0x61, 0x72, 0,
0x76, 0x69, 0x63, 0x69, 0x6f, 0,
0x76, 0x69, 0xcc, 0x81, 0x63, 0x74, 0x69, 0x6d, 0x61, 0,
0x76, 0x69, 0x64, 0x61, 0,
0x76, 0x69, 0xcc, 0x81, 0x64, 0x65, 0x6f, 0,
0x76, 0x69, 0x64, 0x72, 0x69, 0x6f, 0,
0x76, 0x69, 0x65, 0x6a, 0x6f, 0,
0x76, 0x69, 0x65, 0x72, 0x6e, 0x65, 0x73, 0,
0x76, 0x69, 0x67, 0x6f, 0x72, 0,
0x76, 0x69, 0x6c, 0,
0x76, 0x69, 0x6c, 0x6c, 0x61, 0,
0x76, 0x69, 0x6e, 0x61, 0x67, 0x72, 0x65, 0,
0x76, 0x69, 0x6e, 0x6f, 0,
0x76, 0x69, 0x6e, 0xcc, 0x83, 0x65, 0x64, 0x6f, 0,
0x76, 0x69, 0x6f, 0x6c, 0x69, 0xcc, 0x81, 0x6e, 0,
0x76, 0x69, 0x72, 0x61, 0x6c, 0,
0x76, 0x69, 0x72, 0x67, 0x6f, 0,
0x76, 0x69, 0x72, 0x74, 0x75, 0x64, 0,
0x76, 0x69, 0x73, 0x6f, 0x72, 0,
0x76, 0x69, 0xcc, 0x81, 0x73, 0x70, 0x65, 0x72, 0x61, 0,
0x76, 0x69, 0x73, 0x74, 0x61, 0,
0x76, 0x69, 0x74, 0x61, 0x6d, 0x69, 0x6e, 0x61, 0,
0x76, 0x69, 0x75, 0x64, 0x6f, 0,
0x76, 0x69, 0x76, 0x61, 0x7a, 0,
0x76, 0x69, 0x76, 0x65, 0x72, 0x6f, 0,
0x76, 0x69, 0x76, 0x69, 0x72, 0,
0x76, 0x69, 0x76, 0x6f, 0,
0x76, 0x6f, 0x6c, 0x63, 0x61, 0xcc, 0x81, 0x6e, 0,
0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x6e, 0,
0x76, 0x6f, 0x6c, 0x76, 0x65, 0x72, 0,
0x76, 0x6f, 0x72, 0x61, 0x7a, 0,
0x76, 0x6f, 0x74, 0x61, 0x72, 0,
0x76, 0x6f, 0x74, 0x6f, 0,
0x76, 0x6f, 0x7a, 0,
0x76, 0x75, 0x65, 0x6c, 0x6f, 0,
0x76, 0x75, 0x6c, 0x67, 0x61, 0x72, 0,
0x79, 0x61, 0x63, 0x65, 0x72, 0,
0x79, 0x61, 0x74, 0x65, 0,
0x79, 0x65, 0x67, 0x75, 0x61, 0,
0x79, 0x65, 0x6d, 0x61, 0,
0x79, 0x65, 0x72, 0x6e, 0x6f, 0,
0x79, 0x65, 0x73, 0x6f, 0,
0x79, 0x6f, 0x64, 0x6f, 0,
0x79, 0x6f, 0x67, 0x61, 0,
0x79, 0x6f, 0x67, 0x75, 0x72, 0,
0x7a, 0x61, 0x66, 0x69, 0x72, 0x6f, 0,
0x7a, 0x61, 0x6e, 0x6a, 0x61, 0,
0x7a, 0x61, 0x70, 0x61, 0x74, 0x6f, 0,
0x7a, 0x61, 0x72, 0x7a, 0x61, 0,
0x7a, 0x6f, 0x6e, 0x61, 0,
0x7a, 0x6f, 0x72, 0x72, 0x6f, 0,
0x7a, 0x75, 0x6d, 0x6f, 0,
0x7a, 0x75, 0x72, 0x64, 0x6f, 0,
};
#define es ((const char*)es_)
static const char *es_i[] = {
es + 0, es + 8, es + 16, es + 22, es + 30, es + 38,
es + 44, es + 51, es + 58, es + 64, es + 71, es + 77,
es + 84, es + 93, es + 100, es + 109, es + 116, es + 123,
es + 130, es + 138, es + 146, es + 154, es + 161, es + 168,
es + 174, es + 181, es + 186, es + 193, es + 200, es + 207,
es + 215, es + 222, es + 229, es + 237, es + 245, es + 252,
es + 259, es + 266, es + 274, es + 282, es + 292, es + 299,
es + 307, es + 314, es + 321, es + 330, es + 337, es + 344,
es + 352, es + 358, es + 363, es + 369, es + 378, es + 384,
es + 390, es + 397, es + 402, es + 409, es + 417, es + 423,
es + 430, es + 440, es + 448, es + 455, es + 460, es + 468,
es + 476, es + 482, es + 489, es + 496, es + 503, es + 509,
es + 517, es + 522, es + 532, es + 539, es + 547, es + 554,
es + 559, es + 566, es + 576, es + 582, es + 589, es + 596,
es + 601, es + 608, es + 615, es + 621, es + 628, es + 635,
es + 643, es + 650, es + 657, es + 665, es + 674, es + 680,
es + 686, es + 694, es + 699, es + 706, es + 713, es + 719,
es + 727, es + 733, es + 739, es + 747, es + 754, es + 763,
es + 770, es + 778, es + 785, es + 792, es + 799, es + 807,
es + 814, es + 820, es + 827, es + 835, es + 844, es + 852,
es + 858, es + 865, es + 873, es + 881, es + 886, es + 894,
es + 900, es + 907, es + 913, es + 922, es + 930, es + 938,
es + 944, es + 950, es + 958, es + 963, es + 973, es + 981,
es + 989, es + 997, es + 1002, es + 1008, es + 1016, es + 1022,
es + 1029, es + 1037, es + 1043, es + 1053, es + 1061, es + 1067,
es + 1072, es + 1080, es + 1088, es + 1094, es + 1101, es + 1106,
es + 1114, es + 1118, es + 1124, es + 1131, es + 1139, es + 1148,
es + 1153, es + 1160, es + 1168, es + 1174, es + 1182, es + 1187,
es + 1195, es + 1204, es + 1212, es + 1218, es + 1225, es + 1232,
es + 1239, es + 1245, es + 1252, es + 1257, es + 1264, es + 1269,
es + 1277, es + 1284, es + 1292, es + 1299, es + 1305, es + 1312,
es + 1318, es + 1324, es + 1329, es + 1334, es + 1342, es + 1350,
es + 1356, es + 1361, es + 1368, es + 1374, es + 1378, es + 1387,
es + 1393, es + 1402, es + 1410, es + 1416, es + 1421, es + 1427,
es + 1433, es + 1443, es + 1448, es + 1454, es + 1463, es + 1470,
es + 1475, es + 1480, es + 1486, es + 1492, es + 1500, es + 1506,
es + 1512, es + 1520, es + 1529, es + 1535, es + 1543, es + 1549,
es + 1555, es + 1562, es + 1568, es + 1574, es + 1581, es + 1587,
es + 1597, es + 1606, es + 1613, es + 1621, es + 1631, es + 1637,
es + 1644, es + 1651, es + 1657, es + 1664, es + 1671, es + 1677,
es + 1683, es + 1688, es + 1695, es + 1701, es + 1706, es + 1712,
es + 1719, es + 1726, es + 1732, es + 1736, es + 1743, es + 1748,
es + 1753, es + 1760, es + 1765, es + 1772, es + 1778, es + 1783,
es + 1790, es + 1796, es + 1802, es + 1809, es + 1816, es + 1821,
es + 1830, es + 1836, es + 1843, es + 1850, es + 1855, es + 1863,
es + 1872, es + 1878, es + 1884, es + 1890, es + 1897, es + 1903,
es + 1910, es + 1917, es + 1923, es + 1929, es + 1935, es + 1942,
es + 1948, es + 1954, es + 1961, es + 1967, es + 1973, es + 1979,
es + 1985, es + 1990, es + 1998, es + 2006, es + 2013, es + 2020,
es + 2026, es + 2034, es + 2040, es + 2046, es + 2053, es + 2060,
es + 2068, es + 2076, es + 2083, es + 2090, es + 2096, es + 2102,
es + 2112, es + 2119, es + 2124, es + 2131, es + 2139, es + 2148,
es + 2153, es + 2161, es + 2165, es + 2173, es + 2180, es + 2186,
es + 2194, es + 2200, es + 2206, es + 2212, es + 2218, es + 2223,
es + 2230, es + 2238, es + 2245, es + 2251, es + 2260, es + 2267,
es + 2274, es + 2282, es + 2289, es + 2295, es + 2302, es + 2312,
es + 2318, es + 2323, es + 2329, es + 2339, es + 2346, es + 2353,
es + 2361, es + 2366, es + 2375, es + 2384, es + 2391, es + 2397,
es + 2406, es + 2412, es + 2420, es + 2426, es + 2432, es + 2437,
es + 2443, es + 2450, es + 2456, es + 2463, es + 2471, es + 2477,
es + 2484, es + 2490, es + 2495, es + 2503, es + 2509, es + 2515,
es + 2521, es + 2531, es + 2538, es + 2547, es + 2555, es + 2562,
es + 2569, es + 2575, es + 2581, es + 2588, es + 2593, es + 2600,
es + 2608, es + 2617, es + 2623, es + 2630, es + 2638, es + 2647,
es + 2655, es + 2661, es + 2668, es + 2674, es + 2681, es + 2687,
es + 2694, es + 2700, es + 2708, es + 2715, es + 2724, es + 2730,
es + 2736, es + 2741, es + 2748, es + 2754, es + 2762, es + 2767,
es + 2773, es + 2778, es + 2784, es + 2793, es + 2799, es + 2807,
es + 2813, es + 2818, es + 2825, es + 2832, es + 2837, es + 2843,
es + 2849, es + 2855, es + 2863, es + 2869, es + 2879, es + 2885,
es + 2895, es + 2903, es + 2910, es + 2915, es + 2924, es + 2929,
es + 2935, es + 2941, es + 2948, es + 2956, es + 2961, es + 2966,
es + 2973, es + 2981, es + 2988, es + 2995, es + 3002, es + 3008,
es + 3016, es + 3024, es + 3030, es + 3037, es + 3046, es + 3053,
es + 3059, es + 3066, es + 3072, es + 3080, es + 3088, es + 3095,
es + 3100, es + 3106, es + 3116, es + 3124, es + 3131, es + 3140,
es + 3147, es + 3154, es + 3160, es + 3167, es + 3173, es + 3182,
es + 3191, es + 3197, es + 3204, es + 3213, es + 3219, es + 3226,
es + 3233, es + 3240, es + 3247, es + 3253, es + 3263, es + 3272,
es + 3278, es + 3283, es + 3290, es + 3297, es + 3304, es + 3309,
es + 3316, es + 3324, es + 3331, es + 3338, es + 3345, es + 3352,
es + 3358, es + 3365, es + 3373, es + 3379, es + 3385, es + 3392,
es + 3400, es + 3405, es + 3412, es + 3418, es + 3426, es + 3435,
es + 3441, es + 3449, es + 3455, es + 3461, es + 3467, es + 3472,
es + 3478, es + 3482, es + 3488, es + 3496, es + 3502, es + 3510,
es + 3519, es + 3525, es + 3530, es + 3538, es + 3546, es + 3552,
es + 3561, es + 3569, es + 3576, es + 3583, es + 3589, es + 3596,
es + 3604, es + 3612, es + 3620, es + 3629, es + 3635, es + 3643,
es + 3651, es + 3659, es + 3668, es + 3676, es + 3684, es + 3690,
es + 3696, es + 3703, es + 3711, es + 3720, es + 3726, es + 3733,
es + 3740, es + 3747, es + 3754, es + 3760, es + 3765, es + 3775,
es + 3781, es + 3788, es + 3795, es + 3802, es + 3810, es + 3818,
es + 3824, es + 3833, es + 3841, es + 3846, es + 3853, es + 3859,
es + 3864, es + 3870, es + 3878, es + 3882, es + 3888, es + 3895,
es + 3902, es + 3908, es + 3912, es + 3918, es + 3927, es + 3933,
es + 3939, es + 3944, es + 3950, es + 3958, es + 3964, es + 3970,
es + 3976, es + 3982, es + 3989, es + 3994, es + 4002, es + 4008,
es + 4014, es + 4018, es + 4026, es + 4031, es + 4041, es + 4050,
es + 4057, es + 4064, es + 4071, es + 4078, es + 4082, es + 4090,
es + 4099, es + 4106, es + 4115, es + 4122, es + 4129, es + 4137,
es + 4144, es + 4151, es + 4158, es + 4165, es + 4172, es + 4182,
es + 4189, es + 4198, es + 4205, es + 4213, es + 4219, es + 4227,
es + 4235, es + 4243, es + 4251, es + 4257, es + 4264, es + 4272,
es + 4281, es + 4288, es + 4295, es + 4302, es + 4309, es + 4316,
es + 4326, es + 4333, es + 4340, es + 4347, es + 4355, es + 4363,
es + 4370, es + 4376, es + 4383, es + 4390, es + 4398, es + 4407,
es + 4414, es + 4422, es + 4429, es + 4438, es + 4445, es + 4452,
es + 4460, es + 4467, es + 4474, es + 4482, es + 4488, es + 4493,
es + 4500, es + 4507, es + 4513, es + 4520, es + 4528, es + 4534,
es + 4541, es + 4549, es + 4556, es + 4563, es + 4570, es + 4577,
es + 4584, es + 4591, es + 4598, es + 4605, es + 4612, es + 4620,
es + 4628, es + 4636, es + 4645, es + 4653, es + 4661, es + 4671,
es + 4680, es + 4688, es + 4696, es + 4703, es + 4709, es + 4714,
es + 4720, es + 4726, es + 4732, es + 4739, es + 4744, es + 4752,
es + 4759, es + 4768, es + 4777, es + 4783, es + 4789, es + 4794,
es + 4801, es + 4807, es + 4813, es + 4817, es + 4825, es + 4831,
es + 4837, es + 4841, es + 4847, es + 4853, es + 4862, es + 4869,
es + 4878, es + 4885, es + 4892, es + 4897, es + 4903, es + 4913,
es + 4919, es + 4925, es + 4932, es + 4937, es + 4943, es + 4950,
es + 4957, es + 4963, es + 4968, es + 4973, es + 4980, es + 4987,
es + 4994, es + 4998, es + 5004, es + 5011, es + 5018, es + 5024,
es + 5030, es + 5037, es + 5044, es + 5049, es + 5055, es + 5061,
es + 5067, es + 5075, es + 5081, es + 5086, es + 5093, es + 5101,
es + 5107, es + 5115, es + 5121, es + 5127, es + 5133, es + 5141,
es + 5148, es + 5153, es + 5158, es + 5166, es + 5175, es + 5182,
es + 5188, es + 5195, es + 5203, es + 5209, es + 5215, es + 5222,
es + 5228, es + 5234, es + 5240, es + 5247, es + 5254, es + 5259,
es + 5265, es + 5275, es + 5281, es + 5290, es + 5296, es + 5302,
es + 5311, es + 5318, es + 5325, es + 5331, es + 5337, es + 5342,
es + 5347, es + 5357, es + 5363, es + 5369, es + 5375, es + 5382,
es + 5388, es + 5394, es + 5401, es + 5407, es + 5416, es + 5423,
es + 5428, es + 5438, es + 5445, es + 5451, es + 5455, es + 5464,
es + 5470, es + 5476, es + 5484, es + 5492, es + 5499, es + 5505,
es + 5513, es + 5522, es + 5528, es + 5533, es + 5541, es + 5547,
es + 5554, es + 5558, es + 5564, es + 5571, es + 5577, es + 5582,
es + 5588, es + 5595, es + 5601, es + 5606, es + 5612, es + 5618,
es + 5624, es + 5634, es + 5640, es + 5646, es + 5653, es + 5659,
es + 5666, es + 5673, es + 5679, es + 5684, es + 5690, es + 5697,
es + 5704, es + 5711, es + 5717, es + 5723, es + 5730, es + 5736,
es + 5744, es + 5751, es + 5758, es + 5766, es + 5772, es + 5778,
es + 5787, es + 5794, es + 5801, es + 5807, es + 5815, es + 5822,
es + 5828, es + 5834, es + 5839, es + 5846, es + 5853, es + 5860,
es + 5864, es + 5873, es + 5881, es + 5887, es + 5893, es + 5900,
es + 5906, es + 5913, es + 5919, es + 5927, es + 5935, es + 5942,
es + 5948, es + 5955, es + 5964, es + 5972, es + 5977, es + 5983,
es + 5992, es + 5999, es + 6005, es + 6013, es + 6018, es + 6025,
es + 6031, es + 6037, es + 6043, es + 6048, es + 6056, es + 6062,
es + 6069, es + 6074, es + 6080, es + 6087, es + 6094, es + 6100,
es + 6106, es + 6112, es + 6117, es + 6124, es + 6133, es + 6141,
es + 6146, es + 6153, es + 6163, es + 6169, es + 6175, es + 6181,
es + 6188, es + 6196, es + 6204, es + 6211, es + 6217, es + 6224,
es + 6234, es + 6241, es + 6248, es + 6255, es + 6261, es + 6269,
es + 6277, es + 6285, es + 6293, es + 6302, es + 6309, es + 6316,
es + 6324, es + 6332, es + 6339, es + 6347, es + 6354, es + 6361,
es + 6369, es + 6378, es + 6388, es + 6397, es + 6404, es + 6413,
es + 6422, es + 6426, es + 6431, es + 6440, es + 6445, es + 6452,
es + 6461, es + 6469, es + 6477, es + 6484, es + 6493, es + 6499,
es + 6505, es + 6514, es + 6519, es + 6527, es + 6534, es + 6542,
es + 6549, es + 6555, es + 6560, es + 6567, es + 6574, es + 6579,
es + 6587, es + 6592, es + 6600, es + 6607, es + 6613, es + 6620,
es + 6626, es + 6633, es + 6643, es + 6649, es + 6655, es + 6663,
es + 6670, es + 6675, es + 6681, es + 6687, es + 6693, es + 6699,
es + 6704, es + 6713, es + 6721, es + 6731, es + 6738, es + 6744,
es + 6750, es + 6759, es + 6769, es + 6774, es + 6781, es + 6790,
es + 6796, es + 6804, es + 6810, es + 6816, es + 6826, es + 6831,
es + 6839, es + 6845, es + 6852, es + 6858, es + 6863, es + 6868,
es + 6878, es + 6884, es + 6891, es + 6896, es + 6905, es + 6914,
es + 6921, es + 6928, es + 6934, es + 6941, es + 6948, es + 6957,
es + 6966, es + 6972, es + 6978, es + 6983, es + 6991, es + 7000,
es + 7006, es + 7012, es + 7020, es + 7027, es + 7034, es + 7039,
es + 7046, es + 7051, es + 7060, es + 7068, es + 7075, es + 7081,
es + 7087, es + 7095, es + 7103, es + 7108, es + 7117, es + 7127,
es + 7132, es + 7138, es + 7145, es + 7151, es + 7157, es + 7163,
es + 7169, es + 7176, es + 7182, es + 7189, es + 7196, es + 7203,
es + 7210, es + 7217, es + 7224, es + 7229, es + 7238, es + 7243,
es + 7250, es + 7259, es + 7265, es + 7273, es + 7278, es + 7284,
es + 7289, es + 7295, es + 7301, es + 7307, es + 7312, es + 7317,
es + 7323, es + 7328, es + 7335, es + 7340, es + 7344, es + 7351,
es + 7357, es + 7364, es + 7370, es + 7377, es + 7385, es + 7391,
es + 7397, es + 7402, es + 7409, es + 7416, es + 7423, es + 7429,
es + 7434, es + 7441, es + 7447, es + 7453, es + 7459, es + 7465,
es + 7473, es + 7479, es + 7489, es + 7496, es + 7501, es + 7507,
es + 7513, es + 7522, es + 7527, es + 7537, es + 7541, es + 7547,
es + 7553, es + 7560, es + 7567, es + 7574, es + 7583, es + 7592,
es + 7599, es + 7605, es + 7610, es + 7620, es + 7627, es + 7633,
es + 7641, es + 7647, es + 7654, es + 7663, es + 7669, es + 7677,
es + 7683, es + 7691, es + 7697, es + 7706, es + 7714, es + 7720,
es + 7727, es + 7735, es + 7743, es + 7749, es + 7757, es + 7763,
es + 7770, es + 7778, es + 7787, es + 7796, es + 7800, es + 7808,
es + 7813, es + 7819, es + 7828, es + 7834, es + 7841, es + 7847,
es + 7852, es + 7860, es + 7865, es + 7869, es + 7877, es + 7885,
es + 7894, es + 7899, es + 7904, es + 7911, es + 7920, es + 7927,
es + 7933, es + 7939, es + 7944, es + 7952, es + 7958, es + 7964,
es + 7970, es + 7975, es + 7983, es + 7992, es + 7997, es + 8004,
es + 8009, es + 8015, es + 8021, es + 8027, es + 8034, es + 8042,
es + 8048, es + 8056, es + 8063, es + 8069, es + 8075, es + 8082,
es + 8089, es + 8096, es + 8103, es + 8109, es + 8115, es + 8121,
es + 8128, es + 8134, es + 8142, es + 8149, es + 8155, es + 8163,
es + 8168, es + 8174, es + 8180, es + 8187, es + 8193, es + 8200,
es + 8208, es + 8214, es + 8220, es + 8225, es + 8232, es + 8238,
es + 8244, es + 8253, es + 8259, es + 8264, es + 8274, es + 8280,
es + 8286, es + 8295, es + 8301, es + 8309, es + 8318, es + 8324,
es + 8330, es + 8338, es + 8344, es + 8351, es + 8357, es + 8363,
es + 8370, es + 8378, es + 8387, es + 8393, es + 8398, es + 8406,
es + 8412, es + 8421, es + 8427, es + 8435, es + 8441, es + 8448,
es + 8455, es + 8460, es + 8467, es + 8473, es + 8480, es + 8486,
es + 8491, es + 8498, es + 8504, es + 8512, es + 8519, es + 8528,
es + 8534, es + 8542, es + 8548, es + 8557, es + 8563, es + 8569,
es + 8575, es + 8580, es + 8588, es + 8595, es + 8602, es + 8608,
es + 8613, es + 8618, es + 8627, es + 8635, es + 8640, es + 8646,
es + 8652, es + 8657, es + 8662, es + 8671, es + 8678, es + 8684,
es + 8690, es + 8697, es + 8704, es + 8709, es + 8716, es + 8725,
es + 8733, es + 8739, es + 8743, es + 8749, es + 8758, es + 8766,
es + 8771, es + 8776, es + 8781, es + 8788, es + 8796, es + 8803,
es + 8810, es + 8818, es + 8824, es + 8829, es + 8836, es + 8842,
es + 8849, es + 8856, es + 8863, es + 8871, es + 8876, es + 8883,
es + 8889, es + 8893, es + 8897, es + 8904, es + 8911, es + 8917,
es + 8922, es + 8927, es + 8932, es + 8939, es + 8947, es + 8952,
es + 8957, es + 8963, es + 8972, es + 8980, es + 8987, es + 8994,
es + 9000, es + 9009, es + 9017, es + 9027, es + 9034, es + 9039,
es + 9048, es + 9053, es + 9059, es + 9065, es + 9074, es + 9082,
es + 9090, es + 9098, es + 9105, es + 9112, es + 9116, es + 9125,
es + 9131, es + 9140, es + 9147, es + 9154, es + 9158, es + 9164,
es + 9172, es + 9177, es + 9183, es + 9191, es + 9199, es + 9209,
es + 9216, es + 9222, es + 9228, es + 9234, es + 9241, es + 9250,
es + 9255, es + 9262, es + 9271, es + 9279, es + 9285, es + 9292,
es + 9301, es + 9307, es + 9314, es + 9321, es + 9325, es + 9331,
es + 9340, es + 9348, es + 9358, es + 9365, es + 9371, es + 9379,
es + 9387, es + 9393, es + 9401, es + 9407, es + 9413, es + 9418,
es + 9428, es + 9435, es + 9445, es + 9451, es + 9457, es + 9463,
es + 9472, es + 9477, es + 9483, es + 9488, es + 9494, es + 9501,
es + 9507, es + 9513, es + 9518, es + 9525, es + 9534, es + 9541,
es + 9548, es + 9554, es + 9560, es + 9566, es + 9572, es + 9578,
es + 9584, es + 9594, es + 9600, es + 9608, es + 9616, es + 9621,
es + 9628, es + 9633, es + 9640, es + 9650, es + 9657, es + 9662,
es + 9669, es + 9679, es + 9684, es + 9691, es + 9698, es + 9705,
es + 9712, es + 9719, es + 9725, es + 9733, es + 9739, es + 9747,
es + 9752, es + 9758, es + 9767, es + 9777, es + 9786, es + 9797,
es + 9801, es + 9810, es + 9816, es + 9825, es + 9829, es + 9836,
es + 9843, es + 9849, es + 9856, es + 9862, es + 9869, es + 9878,
es + 9883, es + 9890, es + 9896, es + 9903, es + 9909, es + 9914,
es + 9921, es + 9927, es + 9935, es + 9940, es + 9946, es + 9954,
es + 9960, es + 9966, es + 9971, es + 9977, es + 9983, es + 9989,
es + 9996, es + 10002, es + 10008, es + 10014, es + 10021, es + 10027,
es + 10032, es + 10038, es + 10044, es + 10050, es + 10059, es + 10065,
es + 10071, es + 10081, es + 10087, es + 10093, es + 10100, es + 10107,
es + 10112, es + 10118, es + 10124, es + 10134, es + 10141, es + 10148,
es + 10155, es + 10163, es + 10169, es + 10178, es + 10184, es + 10189,
es + 10195, es + 10202, es + 10211, es + 10218, es + 10225, es + 10231,
es + 10238, es + 10244, es + 10255, es + 10265, es + 10272, es + 10277,
es + 10284, es + 10292, es + 10301, es + 10308, es + 10317, es + 10326,
es + 10332, es + 10340, es + 10347, es + 10354, es + 10364, es + 10371,
es + 10381, es + 10389, es + 10395, es + 10402, es + 10409, es + 10416,
es + 10422, es + 10428, es + 10437, es + 10443, es + 10449, es + 10454,
es + 10460, es + 10468, es + 10475, es + 10480, es + 10487, es + 10494,
es + 10501, es + 10507, es + 10514, es + 10521, es + 10527, es + 10534,
es + 10544, es + 10551, es + 10558, es + 10567, es + 10573, es + 10578,
es + 10587, es + 10595, es + 10602, es + 10607, es + 10613, es + 10620,
es + 10626, es + 10632, es + 10641, es + 10647, es + 10653, es + 10659,
es + 10664, es + 10669, es + 10674, es + 10682, es + 10693, es + 10702,
es + 10711, es + 10718, es + 10725, es + 10732, es + 10740, es + 10748,
es + 10755, es + 10761, es + 10769, es + 10773, es + 10781, es + 10789,
es + 10797, es + 10805, es + 10814, es + 10822, es + 10829, es + 10835,
es + 10841, es + 10849, es + 10857, es + 10863, es + 10870, es + 10875,
es + 10882, es + 10889, es + 10897, es + 10905, es + 10911, es + 10917,
es + 10925, es + 10930, es + 10937, es + 10944, es + 10950, es + 10958,
es + 10966, es + 10973, es + 10980, es + 10984, es + 10992, es + 10999,
es + 11007, es + 11013, es + 11021, es + 11028, es + 11036, es + 11044,
es + 11051, es + 11059, es + 11067, es + 11071, es + 11077, es + 11082,
es + 11088, es + 11095, es + 11102, es + 11107, es + 11116, es + 11122,
es + 11131, es + 11141, es + 11147, es + 11155, es + 11160, es + 11166,
es + 11171, es + 11176, es + 11182, es + 11187, es + 11194, es + 11200,
es + 11206, es + 11214, es + 11219, es + 11226, es + 11231, es + 11238,
es + 11245, es + 11249, es + 11255, es + 11261, es + 11266, es + 11273,
es + 11278, es + 11284, es + 11291, es + 11297, es + 11304, es + 11310,
es + 11315, es + 11321, es + 11327, es + 11333, es + 11339, es + 11346,
es + 11351, es + 11357, es + 11363, es + 11371, es + 11376, es + 11383,
es + 11392, es + 11398, es + 11404, es + 11410, es + 11416, es + 11422,
es + 11430, es + 11435, es + 11441, es + 11448, es + 11454, es + 11463,
es + 11471, es + 11477, es + 11483, es + 11489, es + 11496, es + 11502,
es + 11512, es + 11521, es + 11528, es + 11535, es + 11543, es + 11548,
es + 11554, es + 11559, es + 11565, es + 11573, es + 11582, es + 11589,
es + 11597, es + 11603, es + 11613, es + 11623, es + 11628, es + 11636,
es + 11642, es + 11646, es + 11653, es + 11658, es + 11664, es + 11670,
es + 11677, es + 11685, es + 11691, es + 11698, es + 11706, es + 11714,
es + 11722, es + 11728, es + 11737, es + 11741, es + 11747, es + 11756,
es + 11763, es + 11771, es + 11780, es + 11785, es + 11793, es + 11800,
es + 11805, es + 11811, es + 11817, es + 11824, es + 11830, es + 11836,
es + 11842, es + 11851, es + 11858, es + 11867, es + 11873, es + 11883,
es + 11889, es + 11896, es + 11904, es + 11910, es + 11917, es + 11923,
es + 11929, es + 11935, es + 11939, es + 11946, es + 11954, es + 11962,
es + 11971, es + 11978, es + 11989, es + 11996, es + 12003, es + 12010,
es + 12017, es + 12025, es + 12030, es + 12037, es + 12045, es + 12051,
es + 12060, es + 12067, es + 12076, es + 12085, es + 12091, es + 12097,
es + 12104, es + 12110, es + 12117, es + 12123, es + 12131, es + 12138,
es + 12145, es + 12152, es + 12161, es + 12167, es + 12175, es + 12182,
es + 12190, es + 12198, es + 12202, es + 12208, es + 12217, es + 12224,
es + 12230, es + 12236, es + 12243, es + 12251, es + 12257, es + 12264,
es + 12269, es + 12275, es + 12280, es + 12286, es + 12292, es + 12300,
es + 12306, es + 12314, es + 12323, es + 12330, es + 12336, es + 12343,
es + 12348, es + 12355, es + 12361, es + 12369, es + 12378, es + 12384,
es + 12390, es + 12397, es + 12405, es + 12411, es + 12417, es + 12423,
es + 12431, es + 12437, es + 12442, es + 12450, es + 12457, es + 12463,
es + 12469, es + 12479, es + 12486, es + 12492, es + 12499, es + 12504,
es + 12515, es + 12520, es + 12526, es + 12533, es + 12539, es + 12546,
es + 12552, es + 12558, es + 12564, es + 12573, es + 12581, es + 12587,
es + 12597, es + 12605, es + 12612, es + 12618, es + 12625, es + 12633,
es + 12640, es + 12646, es + 12650, es + 12656, es + 12666, es + 12673,
es + 12680, es + 12687, es + 12693, es + 12699, es + 12706, es + 12712,
es + 12719, es + 12728, es + 12733, es + 12739, es + 12745, es + 12754,
es + 12759, es + 12764, es + 12772, es + 12780, es + 12789, es + 12798,
es + 12803, es + 12810, es + 12818, es + 12824, es + 12831, es + 12836,
es + 12841, es + 12847, es + 12853, es + 12858, es + 12864, es + 12870,
es + 12875, es + 12881, es + 12889, es + 12896, es + 12905, es + 12912,
es + 12917, es + 12925, es + 12931, es + 12937, es + 12945, es + 12949,
es + 12955, es + 12961, es + 12970, es + 12978, es + 12986, es + 12992,
es + 13002, es + 13008, es + 13014, es + 13020, es + 13027, es + 13033,
es + 13040, es + 13047, es + 13056, es + 13063, es + 13071, es + 13076,
es + 13083, es + 13088, es + 13094, es + 13100, es + 13106, es + 13113,
es + 13121, es + 13128, es + 13135, es + 13142, es + 13148, es + 13154,
es + 13160, es + 13166, es + 13173, es + 13179, es + 13189, es + 13194,
es + 13201, es + 13207, es + 13213, es + 13221, es + 13230, es + 13238,
es + 13246, es + 13252, es + 13258, es + 13265, es + 13274, es + 13281,
es + 13288, es + 13293, es + 13302, es + 13306, es + 13312, es + 13318,
es + 13325, es + 13330, es + 13338, es + 13343, es + 13348, es + 13356,
es + 13363, es + 13372, es + 13376, es + 13381, es + 13389, es + 13396,
es + 13402, es + 13407, es + 13413, es + 13421, es + 13426, es + 13435,
es + 13441, es + 13447, es + 13457, es + 13465, es + 13470, es + 13477,
es + 13485, es + 13490, es + 13497, es + 13504, es + 13515, es + 13522,
es + 13528, es + 13533, es + 13540, es + 13546, es + 13551, es + 13558,
es + 13564, es + 13571, es + 13578, es + 13584, es + 13590, es + 13596,
es + 13600, es + 13607, es + 13613, es + 13619, es + 13626, es + 13632,
es + 13638, es + 13645, es + 13651, es + 13657, es + 13664, es + 13670,
es + 13680, es + 13685, es + 13693, es + 13700, es + 13706, es + 13714,
es + 13720, es + 13724, es + 13730, es + 13738, es + 13743, es + 13752,
es + 13761, es + 13767, es + 13773, es + 13780, es + 13786, es + 13796,
es + 13802, es + 13811, es + 13817, es + 13823, es + 13830, es + 13836,
es + 13841, es + 13850, es + 13858, es + 13865, es + 13871, es + 13877,
es + 13882, es + 13886, es + 13892, es + 13899, es + 13905, es + 13910,
es + 13916, es + 13921, es + 13927, es + 13932, es + 13937, es + 13942,
es + 13948, es + 13955, es + 13961, es + 13968, es + 13974, es + 13979,
es + 13985, es + 13990, es + 13996,
};
#undef es
const struct words es_words = {
2048,
11,
false,
(const char *) es_,
0, /* Constant string */
es_i
};
| 45.94313 | 75 | 0.56701 | xdvio |
792aac92a339463a13ff12d3c3d39467583bc31e | 1,770 | cpp | C++ | benchmarks/automatic_comm/edgeautodist_tiramisu.cpp | akmaru/tiramisu | 8ca4173547b6d12cff10575ef0dc48cf93f7f414 | [
"MIT"
] | 23 | 2017-05-03T13:06:34.000Z | 2018-06-07T07:12:43.000Z | benchmarks/automatic_comm/edgeautodist_tiramisu.cpp | akmaru/tiramisu | 8ca4173547b6d12cff10575ef0dc48cf93f7f414 | [
"MIT"
] | 2 | 2017-04-25T08:59:09.000Z | 2017-05-11T16:41:55.000Z | benchmarks/automatic_comm/edgeautodist_tiramisu.cpp | akmaru/tiramisu | 8ca4173547b6d12cff10575ef0dc48cf93f7f414 | [
"MIT"
] | 5 | 2017-02-16T14:26:40.000Z | 2018-05-30T16:49:27.000Z | #include <tiramisu/tiramisu.h>
#include "wrapper_edgeautodist.h"
using namespace tiramisu;
int main(int argc, char* argv[])
{
tiramisu::init("edgeautodist_tiramisu");
constant COLS("COLS",_COLS);
constant ROWS("ROWS",_ROWS);
function* edge = global::get_implicit_function();
edge->add_context_constraints("[ROWS]->{:ROWS = "+std::to_string(_ROWS)+"}");
var ir("ir", 0, ROWS-2), jr("jr", 0, COLS-2), c("c", 0, 3), ii("ii"), jj("jj"), kk("kk"), p("p"),q("q"), i1("i1"), i0("i0"), jn("jn", 0, COLS);
var in("in", 0, ROWS);
var iout("iout", 0, ROWS-4), jout("jout", 0, COLS-4);
var s("s"); var r("r");
input Img("Img", {in, jn, c}, p_int32);
computation R("R", {ir, jr, c}, (Img(ir, jr, c) + Img(ir, jr+1, c) + Img(ir, jr+2, c) +
Img(ir+1, jr, c) + Img(ir+1, jr+2, c)+ Img(ir+2, jr, c) + Img(ir+2, jr+1, c)
+ Img(ir+2, jr+2, c))/((int32_t) 8));
computation Out("Out", {iout, jout, c}, (R(iout+1, jout+1, c) - R(iout+2, jout, c))
+ (R(iout+2, jout+1, c) - R(iout+1, jout, c)));
R.before(Out, computation::root);
Img.split(in,_ROWS/_NODES,i0,i1);
Out.split(iout,_ROWS/_NODES,i0,i1);
R.split(ir,_ROWS/_NODES,i0,i1);
Img.tag_distribute_level(i0);
Out.tag_distribute_level(i0);
R.tag_distribute_level(i0);
Img.drop_rank_iter(i0);
Out.drop_rank_iter(i0);
R.drop_rank_iter(i0);
buffer b_Img("b_Img", {_ROWS/_NODES, _COLS, 3}, p_int32, a_input);
buffer b_R("b_R", {_ROWS/_NODES, _COLS, 3}, p_int32, a_output);
Img.store_in(&b_Img);
R.store_in(&b_R);
Out.store_in(&b_Img);
R.gen_communication();
Out.gen_communication();
tiramisu::codegen({&b_Img, &b_R}, "build/generated_fct_edgeautodist.o");
return 0;
}
| 30.517241 | 147 | 0.583616 | akmaru |
792b3b93cc098764ec82483fbcc3ad24d3d74f5e | 958 | cc | C++ | TopQuarkAnalysis/TopKinFitter/src/TopKinFitter.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 3 | 2018-08-24T19:10:26.000Z | 2019-02-19T11:45:32.000Z | TopQuarkAnalysis/TopKinFitter/src/TopKinFitter.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 3 | 2018-08-23T13:40:24.000Z | 2019-12-05T21:16:03.000Z | TopQuarkAnalysis/TopKinFitter/src/TopKinFitter.cc | nistefan/cmssw | ea13af97f7f2117a4f590a5e654e06ecd9825a5b | [
"Apache-2.0"
] | 5 | 2018-08-21T16:37:52.000Z | 2020-01-09T13:33:17.000Z | #include "TopQuarkAnalysis/TopKinFitter/interface/TopKinFitter.h"
/// default configuration is: max iterations = 200, max deltaS = 5e-5, maxF = 1e-4
TopKinFitter::TopKinFitter(const int maxNrIter, const double maxDeltaS, const double maxF,
const double mW, const double mTop):
maxNrIter_(maxNrIter), maxDeltaS_(maxDeltaS), maxF_(maxF), mW_(mW), mTop_(mTop)
{
fitter_ = new TKinFitter("TopKinFitter", "TopKinFitter");
fitter_->setMaxNbIter(maxNrIter_);
fitter_->setMaxDeltaS(maxDeltaS_);
fitter_->setMaxF(maxF_);
fitter_->setVerbosity(0);
}
/// default destructor
TopKinFitter::~TopKinFitter()
{
delete fitter_;
}
/// convert Param to human readable form
std::string
TopKinFitter::param(const Param& param) const
{
std::string parName;
switch(param){
case kEMom : parName="EMom"; break;
case kEtEtaPhi : parName="EtEtaPhi"; break;
case kEtThetaPhi : parName="EtThetaPhi"; break;
}
return parName;
}
| 29.030303 | 90 | 0.716075 | nistefan |
792cbb7ef29edd92cecb77d6adc5eec00c43f4ef | 13,490 | cpp | C++ | src/ProjectForecast/Systems/GMSRoomManagementSystem.cpp | yxbh/Project-Forecast | 8ea2f6249a38c9e7f4d6d7d1e51e11ad0b05c2c4 | [
"BSD-3-Clause"
] | 4 | 2019-04-09T13:03:11.000Z | 2021-01-27T04:58:29.000Z | src/ProjectForecast/Systems/GMSRoomManagementSystem.cpp | yxbh/Project-Forecast | 8ea2f6249a38c9e7f4d6d7d1e51e11ad0b05c2c4 | [
"BSD-3-Clause"
] | 2 | 2017-02-06T03:48:45.000Z | 2020-08-31T01:30:10.000Z | src/ProjectForecast/Systems/GMSRoomManagementSystem.cpp | yxbh/Project-Forecast | 8ea2f6249a38c9e7f4d6d7d1e51e11ad0b05c2c4 | [
"BSD-3-Clause"
] | 4 | 2020-06-28T08:19:53.000Z | 2020-06-28T16:30:19.000Z | #include "GMSRoomManagementSystem.hpp"
#include "../Events/GMSRoomLoadRequestEvent.hpp"
#include "../AssetResources/GMSRoomResource.hpp"
#include "../AssetResources/GMSObjectResource.hpp"
#include "../AssetResources/OtherGMSResources.hpp"
#include "../AssetResources/TextureInfoResource.hpp"
#include <KEngine/Graphics/SceneNodes.hpp>
#include <KEngine/Entity/Components/EntityRenderableComponents.hpp>
#include <KEngine/Events/OtherGraphicsEvents.hpp>
#include <KEngine/App.hpp>
#include <KEngine/Core/EventManager.hpp>
#include <KEngine/Log/Log.hpp>
#include <KEngine/Common/ScopeFunc.hpp>
#include <filesystem>
#include <unordered_set>
namespace
{
static const auto ProjectForecastExecAssetsRoot = "D:/workspace/ProjectForecastExecAssetsRoot";
}
namespace pf
{
static auto logger = ke::Log::createDefaultLogger("pf::GMSRoomManagementSystem");
bool GMSRoomManagementSystem::initialise()
{
ke::EventManager::registerListener<pf::GMSRoomLoadRequestEvent>(this, &GMSRoomManagementSystem::handleGMSRoomLoadRequest);
return true;
}
void GMSRoomManagementSystem::shutdown()
{
this->unloadCurrentEntities();
ke::EventManager::deregisterListener<pf::GMSRoomLoadRequestEvent>(this, &GMSRoomManagementSystem::handleGMSRoomLoadRequest);
}
void GMSRoomManagementSystem::update(ke::Time elapsedTime)
{
KE_UNUSED(elapsedTime);
auto currentHumanView = ke::App::instance()->getLogic()->getCurrentHumanView();
if (currentHumanView)
{
auto currentCameraNode = dynamic_cast<ke::CameraNode*>(currentHumanView->getScene()->getCameraNode());
if (currentCameraNode)
{
if (this->currentLevelName == "Desolate Forest")
{
this->updateRorLevelBg_DesolateForest(currentCameraNode);
}
else if (this->currentLevelName == "Dry Lake")
{
this->updateRorLevelBg_DryLake(currentCameraNode);
}
}
}
}
void GMSRoomManagementSystem::handleGMSRoomLoadRequest(ke::EventSptr event)
{
auto request = std::dynamic_pointer_cast<pf::GMSRoomLoadRequestEvent>(event);
if (nullptr == request)
{
logger->error("GMSRoomManagementSystem received unexpected event: {}", event->getName());
return;
}
if (this->isLoadingRoom)
{
logger->warn("GMSRoomManagementSystem is alreadying loading a room. Ignoring new load request.");
return;
}
this->isLoadingRoom = true;
KE_MAKE_SCOPEFUNC([this]() { isLoadingRoom = false; });
this->unloadCurrentEntities();
if (this->currentRoomResource)
{
logger->info("Unloading GM:S room: {} ...", this->currentRoomResource->getName());
auto entityManager = ke::App::instance()->getLogic()->getEntityManager();
for (auto entity : this->currentRoomEntities)
{
entityManager->removeEntity(entity->getId());
}
this->currentRoomEntities.clear();
this->currentRoomResource = nullptr;
/*for (const auto & bgInfo : this->currentRoomResource->getBackgroundInfos())
{
ke::EventManager::enqueue(ke::makeEvent<ke::TextureUnloadRequestEvent>(bgInfo.bg, bgInfo.bg_hash));
}*/
}
if (request->getRoomName().empty())
{
// We interpret an empty room name as a room unload only request.
return;
}
auto resourceManager = ke::App::instance()->getResourceManager();
this->currentRoomResource = std::dynamic_pointer_cast<GMSRoomResource>(resourceManager->getResource(request->getRoomName()));
if (this->currentRoomResource != nullptr)
{
logger->info("Loading GM:S room: {} ...", request->getRoomName());
auto textureLoadRequestEvent = ke::makeEvent<ke::TexturesBulkLoadViaFilesRequestEvent>();
const auto texpagesResource = std::dynamic_pointer_cast<pf::TexpageMapResource>(resourceManager->getResource("texpages"));
assert(texpagesResource);
for (const auto & bgInfo : this->currentRoomResource->getBackgroundInfos())
{
if (bgInfo.bg.length() != 0)
{
auto textureInfo = std::dynamic_pointer_cast<TextureInfoResource>(resourceManager->getResource(bgInfo.bg));
if (textureInfo)
{
textureLoadRequestEvent->addTextureInfo(textureInfo->getName(), textureInfo->getTextureId(), textureInfo->getSourcePath());
}
}
}
ke::EventManager::enqueue(ke::makeEvent<ke::SetClearColourRequestEvent>(this->currentRoomResource->getColour()));
// Instantiate tile entities.
std::unordered_set<unsigned> sheetIds;
auto entityManager = ke::App::instance()->getLogic()->getEntityManager();
for (const auto & tile : this->currentRoomResource->getTiles())
{
auto bgResource = std::dynamic_pointer_cast<pf::GMSBgResource>(resourceManager->getResource(tile.bg));
if (bgResource)
{
const auto texpageResource = texpagesResource->texpages[bgResource->texture].get();
const auto textureId = texpageResource->sheetid;
sheetIds.insert(textureId);
ke::Transform2D transform;
transform.x = static_cast<ke::Transform2D::PointType>(tile.pos.x);
transform.y = static_cast<ke::Transform2D::PointType>(tile.pos.y);
transform.scaleX = tile.scale.x;
transform.scaleY = tile.scale.y;
ke::Rect2DInt32 textureRect;
textureRect.top = tile.sourcepos.y;
textureRect.left = tile.sourcepos.x;
textureRect.width = tile.size.width;
textureRect.height = tile.size.height;
const ke::Point2DInt32 origin{ 0,0 };
auto tileEntity = entityManager->newEntity(tile.instanceid).lock();
tileEntity->setName(tile.bg);
tileEntity->addComponent(ke::makeEntityComponent<ke::SpriteDrawableComponent>(
tileEntity, transform, origin, tile.tiledepth, textureId, textureRect, tile.colour));
this->currentRoomEntities.push_back(tileEntity.get());
}
}
// Instantiate background entities.
std::unordered_set<std::shared_ptr<TextureInfoResource>> backgroundTextureInfos;
ke::graphics::DepthType depth = std::numeric_limits<ke::graphics::DepthType>::min();
for (const auto & bgInfo : this->currentRoomResource->getBackgroundInfos())
{
if (!bgInfo.enabled) continue;
auto bgResource = std::dynamic_pointer_cast<pf::GMSBgResource>(resourceManager->getResource(bgInfo.bg));
if (bgResource)
{
const auto texpageResource = texpagesResource->texpages[bgResource->texture].get();
const auto textureId = texpageResource->sheetid;
ke::Transform2D transform;
transform.x = static_cast<ke::Transform2D::PointType>(bgInfo.pos.x);
transform.y = static_cast<ke::Transform2D::PointType>(bgInfo.pos.y);
transform.scaleX = 1.0f;
transform.scaleY = 1.0f;
ke::Rect2DInt32 textureRect;
textureRect.top = bgInfo.sourcepos.y;
textureRect.left = bgInfo.sourcepos.x;
textureRect.width = bgInfo.size.width;
textureRect.height = bgInfo.size.height;
++depth;
const ke::Point2DInt32 origin{ 0,0 };
auto bgEntity = entityManager->newEntity().lock();
bgEntity->setName(bgInfo.bg);
auto drawableComponent = ke::makeEntityComponent<ke::TiledSpriteDrawablwComponent>(
bgEntity, transform, origin, depth, textureId, textureRect, ke::Color::WHITE, bgInfo.tilex, bgInfo.tiley);
bgEntity->addComponent(drawableComponent);
this->currentRoomEntities.push_back(bgEntity.get());
this->currentRoomBgEntities.push_back(bgEntity.get());
}
}
// Instantiate room objects.
auto entityFactory = ke::App::instance()->getLogic()->getEntityFactory();
for (const auto & objInfo : this->currentRoomResource->getObjects())
{
auto e = entityFactory->createNew(objInfo.obj, objInfo);
if (e)
{
this->currentRoomEntities.push_back(e);
// Compute texture to load.
const auto objectResource = std::static_pointer_cast<GMSObjectResource>(resourceManager->getResource(objInfo.obj));
const auto spriteResource = objectResource->spriteResource;
for (const auto texpageResource : spriteResource->texpageResources)
{
sheetIds.insert(texpageResource->sheetid);
}
}
else
{
logger->error("Failed to create instance of: {}", objInfo.obj);
}
}
// Load textures.
for (const auto sheetId : sheetIds)
{
const auto textureInfo = std::dynamic_pointer_cast<pf::TextureInfoResource>(resourceManager->getResource("texture_" + std::to_string(sheetId)));
assert(textureInfo);
textureLoadRequestEvent->addTextureInfo(textureInfo->getName(), textureInfo->getTextureId(), textureInfo->getSourcePath());
}
ke::EventManager::enqueue(textureLoadRequestEvent);
logger->info("Loading GM:S room: {} ... DONE", request->getRoomName());
}
else
{
logger->error("Cannot load GM:S room: {}. Room resource is missing.", request->getRoomName());
}
}
void GMSRoomManagementSystem::unloadCurrentEntities()
{
auto entityManager = ke::App::instance()->getLogic()->getEntityManager();
for (auto entity : this->currentRoomEntities) entityManager->removeEntity(entity->getId());
this->currentRoomEntities.clear();
this->currentRoomBgEntities.clear();
}
void GMSRoomManagementSystem::updateRorLevelBg_DesolateForest(ke::CameraNode * p_cameraNode)
{
const auto cameraViewDimension = p_cameraNode->getViewDimension();
const auto cameraViewTransform = p_cameraNode->getGlobalTransform();
ke::Point2DDouble cameraTopLeftPos;
cameraTopLeftPos.x = cameraViewTransform.x - cameraViewDimension.width / 2;
cameraTopLeftPos.y = cameraViewTransform.y + cameraViewDimension.height / 2;
for (int i = 0; i < this->currentRoomBgEntities.size(); ++i)
{
auto entity = this->currentRoomBgEntities[i];
auto bgComponent = entity->getComponent<ke::TiledSpriteDrawablwComponent>(ke::TiledSpriteDrawablwComponent::TYPE).lock();
auto node = bgComponent->getSceneNode();
switch (i)
{
case 0: // bStars
{
node->setLocalTransform(cameraViewTransform);
break;
}
case 1: // bPlanets
{
ke::Transform2D newTransform;
newTransform.x = cameraTopLeftPos.x + cameraViewDimension.width * 0.666666666666667;
newTransform.y = cameraTopLeftPos.y - cameraViewDimension.height * 0.142857142857143;
node->setLocalTransform(newTransform);
break;
}
case 2: // bClouds1
{
ke::Transform2D newTransform;
newTransform.x = cameraTopLeftPos.x / 1.1 + 140;
newTransform.y = cameraTopLeftPos.y / 1.07 - 60;
node->setLocalTransform(newTransform);
break;
}
case 3: // bClouds2
{
ke::Transform2D newTransform;
newTransform.x = cameraTopLeftPos.x / 1.2;
newTransform.y = cameraTopLeftPos.y / 1.1 - 106;
node->setLocalTransform(newTransform);
break;
}
case 4: // bMountains
{
ke::Transform2D newTransform;
newTransform.x = cameraTopLeftPos.x;
newTransform.y = cameraTopLeftPos.y - cameraViewDimension.height + 153;
node->setLocalTransform(newTransform);
break;
}
}
}
}
void GMSRoomManagementSystem::updateRorLevelBg_DryLake(ke::CameraNode * p_cameraNode)
{
return this->updateRorLevelBg_DesolateForest(p_cameraNode);
}
} | 44.229508 | 160 | 0.58169 | yxbh |
792cc47b1dbf56bd68acd38bcf0219d1be6e0f88 | 2,829 | cpp | C++ | Sources/Internal/Network/Private/TCPServerTransport.cpp | stinvi/dava.engine | 2b396ca49cdf10cdc98ad8a9ffcf7768a05e285e | [
"BSD-3-Clause"
] | 26 | 2018-09-03T08:48:22.000Z | 2022-02-14T05:14:50.000Z | Sources/Internal/Network/Private/TCPServerTransport.cpp | ANHELL-blitz/dava.engine | ed83624326f000866e29166c7f4cccfed1bb41d4 | [
"BSD-3-Clause"
] | null | null | null | Sources/Internal/Network/Private/TCPServerTransport.cpp | ANHELL-blitz/dava.engine | ed83624326f000866e29166c7f4cccfed1bb41d4 | [
"BSD-3-Clause"
] | 45 | 2018-05-11T06:47:17.000Z | 2022-02-03T11:30:55.000Z | #include <Functional/Function.h>
#include <Debug/DVAssert.h>
#include <Network/Base/IOLoop.h>
#include <Network/Private/TCPClientTransport.h>
#include <Network/Private/TCPServerTransport.h>
namespace DAVA
{
namespace Net
{
TCPServerTransport::TCPServerTransport(IOLoop* aLoop, const Endpoint& aEndpoint, uint32 readTimeout_)
: loop(aLoop)
, endpoint(aEndpoint)
, acceptor(aLoop)
, listener(NULL)
, isTerminating(false)
, readTimeout(readTimeout_)
{
DVASSERT(loop != NULL);
}
TCPServerTransport::~TCPServerTransport()
{
DVASSERT(NULL == listener && false == isTerminating && true == spawnedClients.empty());
}
int32 TCPServerTransport::Start(IServerListener* aListener)
{
DVASSERT(NULL == listener && false == isTerminating && aListener != NULL);
listener = aListener;
return DoStart();
}
void TCPServerTransport::Stop()
{
DVASSERT(listener != NULL && false == isTerminating);
isTerminating = true;
DoStop();
}
void TCPServerTransport::Reset()
{
DVASSERT(listener != NULL && false == isTerminating);
DoStop();
}
void TCPServerTransport::ReclaimClient(IClientTransport* client)
{
DVASSERT(spawnedClients.find(client) != spawnedClients.end());
if (spawnedClients.find(client) != spawnedClients.end())
{
spawnedClients.erase(client);
SafeDelete(client);
}
}
int32 TCPServerTransport::DoStart()
{
int32 error = acceptor.Bind(endpoint);
if (0 == error)
{
error = acceptor.StartListen(MakeFunction(this, &TCPServerTransport::AcceptorHandleConnect));
}
return error;
}
void TCPServerTransport::DoStop()
{
if (acceptor.IsOpen() && !acceptor.IsClosing())
{
acceptor.Close(MakeFunction(this, &TCPServerTransport::AcceptorHandleClose));
}
}
void TCPServerTransport::AcceptorHandleClose(TCPAcceptor* acceptor)
{
if (isTerminating)
{
IServerListener* p = listener;
listener = NULL;
isTerminating = false;
p->OnTransportTerminated(this); // This can be the last executed line of object instance
}
else
{
DoStart();
}
}
void TCPServerTransport::AcceptorHandleConnect(TCPAcceptor* acceptor, int32 error)
{
if (true == isTerminating)
return;
if (0 == error)
{
TCPClientTransport* client = new TCPClientTransport(loop, readTimeout);
error = acceptor->Accept(&client->Socket());
if (0 == error)
{
spawnedClients.insert(client);
listener->OnTransportSpawned(this, client);
}
else
{
SafeDelete(client);
}
}
else
{
DoStop();
}
}
} // namespace Net
} // namespace DAVA
| 23.773109 | 102 | 0.624249 | stinvi |
792cfe158360577bc0a80ff036dba3e4304b7250 | 512 | hpp | C++ | EiRas/Framework/Component/LogSys/LogManager.hpp | MonsterENT/EiRas | b29592da60b1a9085f5a2d8fa4ed01b43660f712 | [
"MIT"
] | 1 | 2019-12-24T10:12:16.000Z | 2019-12-24T10:12:16.000Z | EiRas/Framework/Component/LogSys/LogManager.hpp | MonsterENT/EiRas | b29592da60b1a9085f5a2d8fa4ed01b43660f712 | [
"MIT"
] | null | null | null | EiRas/Framework/Component/LogSys/LogManager.hpp | MonsterENT/EiRas | b29592da60b1a9085f5a2d8fa4ed01b43660f712 | [
"MIT"
] | null | null | null | //
// LogManager.hpp
// EiRasMetalBuild
//
// Created by MonsterENT on 1/7/20.
// Copyright © 2020 MonsterENT. All rights reserved.
//
#ifndef LogManager_hpp
#define LogManager_hpp
#include <string>
#include <Global/GlobalDefine.h>
namespace LogSys {
class LogManager
{
public:
static void DebugPrint(std::string str);
static void DebugPrint(int i);
static void DebugPrint(float f);
static void DebugPrint(double d);
static void DebugPrint(_uint ui);
};
}
#endif /* LogManager_hpp */
| 18.285714 | 53 | 0.708984 | MonsterENT |
792f856eec0bfa0b84754b95d0ebf9e93ebe8d6d | 661 | hpp | C++ | src/core/kext/RemapFunc/ForceNumLockOn.hpp | gkb/Karabiner | f47307d4fc89a4c421d10157d059293c508f721a | [
"Unlicense"
] | null | null | null | src/core/kext/RemapFunc/ForceNumLockOn.hpp | gkb/Karabiner | f47307d4fc89a4c421d10157d059293c508f721a | [
"Unlicense"
] | null | null | null | src/core/kext/RemapFunc/ForceNumLockOn.hpp | gkb/Karabiner | f47307d4fc89a4c421d10157d059293c508f721a | [
"Unlicense"
] | null | null | null | #ifndef FORCENUMLOCKON_HPP
#define FORCENUMLOCKON_HPP
#include "RemapFuncBase.hpp"
namespace org_pqrs_Karabiner {
namespace RemapFunc {
class ForceNumLockOn final : public RemapFuncBase {
public:
ForceNumLockOn(void) : RemapFuncBase(BRIDGE_REMAPTYPE_FORCENUMLOCKON),
index_(0), forceOffMode_(false) {}
bool remapForceNumLockOn(ListHookedKeyboard::Item* item) override;
// ----------------------------------------
// [0] => DeviceVendor
// [1] => DeviceProduct
void add(AddDataType datatype, AddValue newval) override;
private:
size_t index_;
DeviceIdentifier deviceIdentifier_;
bool forceOffMode_;
};
}
}
#endif
| 22.793103 | 72 | 0.69289 | gkb |
79321995f0a323a5d0c3fe1abc92af50403e8719 | 1,360 | cpp | C++ | Day1-1/main.cpp | MPC-Game-Programming-Practice/Prantice | 42097c970aa5cb31fad31841db70f6fcc3536fb5 | [
"BSD-2-Clause"
] | null | null | null | Day1-1/main.cpp | MPC-Game-Programming-Practice/Prantice | 42097c970aa5cb31fad31841db70f6fcc3536fb5 | [
"BSD-2-Clause"
] | null | null | null | Day1-1/main.cpp | MPC-Game-Programming-Practice/Prantice | 42097c970aa5cb31fad31841db70f6fcc3536fb5 | [
"BSD-2-Clause"
] | null | null | null | #include <iostream>
using namespace std;
// 以下に、和とスカラー倍の定義されたベクトルを表す構造体 Vector を定義する
// Vector構造体のメンバ変数を書く
// double x x座標を表す
// double y y座標を表す
// コンストラクタの定義を書く
// 引数：double argX, double argY (それぞれx座標の値、y座標の値を表す)
// コンストラクタの説明：メンバー変数xにargXを代入し、メンバー変数yにargYを代入する。
// メンバ関数 multiply の定義を書く
// 関数名：multiply
// 引数：double a
// 返り値：Vector
// 関数の説明：
// 新たにVector型のオブジェクトを生成して返す。
// ただし、生成するオブジェクトが持つx座標とy座標は以下の通り。
// x座標：元のメンバ変数xと引数で受け取った実数aの積
// y座標：元のメンバ変数yと引数で受け取った実数aの積
// メンバ関数 plus の定義を書く
// 関数名：plus
// 引数：Vector v
// 返り値：Vector
// 関数の説明：
// 新たにVector型のオブジェクトを生成して返す。
// ただし、生成するオブジェクトが持つx座標とy座標は以下の値となるようにする。
// x座標：元のメンバ変数xと引数で受け取ったベクトルvのメンバ変数xの和
// y座標：元のメンバ変数yと引数で受け取ったベクトルvのメンバ変数yの和
//メンバ関数数 print の定義を書く
// 関数名：print
// 引数：なし
// 返り値：なし
// 関数の説明：このオブジェクトが持つメンバ変数xとyを空白区切りで出力し、最後に改行する。
// -------------------
// ここから先は変更しない
// -------------------
int main() {
// 入力を受け取る
double x0, y0, x1, y1, a;
cin >> x0 >> y0 >> x1 >> y1 >> a;
// Vector構造体のオブジェクトを宣言
Vector v0(x0, y0), v1(x1,y1);
// v0、v1を表示
cout << "v0" << endl;
v0.print();
cout << "v1" << endl;
v1.print();
Vector v2=v0.multiply(a);
cout << "v2" << endl;
v2.print();
Vector v3=v0.plus(v1);
cout << "v3" << endl;
v3.print();
}
// 入力例
// 1 2 3 4 5
// 0 0 1 -1 -2
// 1 -1 0 0 3
// -1 2 -2 3 0
// -2 3 -4 5 -3
| 17.894737 | 53 | 0.616912 | MPC-Game-Programming-Practice |
793273692c2ce0dcdae4f6ccf45613c446de10da | 4,255 | hpp | C++ | src/include/duckdb/parser/expression/function_expression.hpp | lokax/duckdb | c2581dfebccaebae9468c924c2c722fcf0306944 | [
"MIT"
] | 1 | 2021-12-13T06:00:18.000Z | 2021-12-13T06:00:18.000Z | src/include/duckdb/parser/expression/function_expression.hpp | lokax/duckdb | c2581dfebccaebae9468c924c2c722fcf0306944 | [
"MIT"
] | 32 | 2021-09-24T23:50:09.000Z | 2022-03-29T09:37:26.000Z | src/include/duckdb/parser/expression/function_expression.hpp | lokax/duckdb | c2581dfebccaebae9468c924c2c722fcf0306944 | [
"MIT"
] | null | null | null | //===----------------------------------------------------------------------===//
// DuckDB
//
// duckdb/parser/expression/function_expression.hpp
//
//
//===----------------------------------------------------------------------===//
#pragma once
#include "duckdb/common/vector.hpp"
#include "duckdb/parser/parsed_expression.hpp"
#include "duckdb/parser/result_modifier.hpp"
namespace duckdb {
//! Represents a function call
class FunctionExpression : public ParsedExpression {
public:
DUCKDB_API FunctionExpression(string schema_name, const string &function_name,
vector<unique_ptr<ParsedExpression>> children,
unique_ptr<ParsedExpression> filter = nullptr,
unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
bool is_operator = false, bool export_state = false);
DUCKDB_API FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
unique_ptr<ParsedExpression> filter = nullptr,
unique_ptr<OrderModifier> order_bys = nullptr, bool distinct = false,
bool is_operator = false, bool export_state = false);
//! Schema of the function
string schema;
//! Function name
string function_name;
//! Whether or not the function is an operator, only used for rendering
bool is_operator;
//! List of arguments to the function
vector<unique_ptr<ParsedExpression>> children;
//! Whether or not the aggregate function is distinct, only used for aggregates
bool distinct;
//! Expression representing a filter, only used for aggregates
unique_ptr<ParsedExpression> filter;
//! Modifier representing an ORDER BY, only used for aggregates
unique_ptr<OrderModifier> order_bys;
//! whether this function should export its state or not
bool export_state;
public:
string ToString() const override;
unique_ptr<ParsedExpression> Copy() const override;
static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
hash_t Hash() const override;
void Serialize(FieldWriter &writer) const override;
static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
void Verify() const override;
public:
template <class T, class BASE>
static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
bool export_state = false, bool add_alias = false) {
if (is_operator) {
// built-in operator
D_ASSERT(!distinct);
if (entry.children.size() == 1) {
if (StringUtil::Contains(function_name, "__postfix")) {
return "(" + entry.children[0]->ToString() + ")" +
StringUtil::Replace(function_name, "__postfix", "");
} else {
return function_name + "(" + entry.children[0]->ToString() + ")";
}
} else if (entry.children.size() == 2) {
return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
")";
}
}
// standard function call
string result = schema.empty() ? function_name : schema + "." + function_name;
result += "(";
if (distinct) {
result += "DISTINCT ";
}
result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
return child->alias.empty() || !add_alias
? child->ToString()
: KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
});
// ordered aggregate
if (order_bys && !order_bys->orders.empty()) {
if (entry.children.empty()) {
result += ") WITHIN GROUP (";
}
result += " ORDER BY ";
for (idx_t i = 0; i < order_bys->orders.size(); i++) {
if (i > 0) {
result += ", ";
}
result += order_bys->orders[i].ToString();
}
}
result += ")";
// filtered aggregate
if (filter) {
result += " FILTER (WHERE " + filter->ToString() + ")";
}
if (export_state) {
result += " EXPORT_STATE";
}
return result;
}
};
} // namespace duckdb
| 36.059322 | 116 | 0.617626 | lokax |
a6ac01778660ac018b5a2ea5a2dbab3f6ec95ba5 | 1,850 | cpp | C++ | cc/blink/WebImageLayerImpl.cpp | wenfeifei/miniblink49 | 2ed562ff70130485148d94b0e5f4c343da0c2ba4 | [
"Apache-2.0"
] | 5,964 | 2016-09-27T03:46:29.000Z | 2022-03-31T16:25:27.000Z | cc/blink/WebImageLayerImpl.cpp | w4454962/miniblink49 | b294b6eacb3333659bf7b94d670d96edeeba14c0 | [
"Apache-2.0"
] | 459 | 2016-09-29T00:51:38.000Z | 2022-03-07T14:37:46.000Z | cc/blink/WebImageLayerImpl.cpp | w4454962/miniblink49 | b294b6eacb3333659bf7b94d670d96edeeba14c0 | [
"Apache-2.0"
] | 1,006 | 2016-09-27T05:17:27.000Z | 2022-03-30T02:46:51.000Z |
#include "WebImageLayerImpl.h"
#include "third_party/WebKit/public/platform/WebImageLayer.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "cc/blink/WebLayerImpl.h"
#include "cc/raster/SkBitmapRefWrap.h"
#include "cc/raster/RasterTask.h"
namespace cc_blink {
WebImageLayerImpl::WebImageLayerImpl()
: m_bitmap(new cc::SkBitmapRefWrap())
{
m_bitmap->ref();
m_layer = new WebLayerImpl(this);
m_layer->setDrawsContent(true);
}
WebImageLayerImpl::~WebImageLayerImpl()
{
m_bitmap->deref();
m_bitmap = nullptr;
//m_layer->parent()->replaceChild(m_layer, nullptr);
m_layer->removeFromParent();
m_layer->setParent(nullptr);
delete m_layer;
}
WebLayerImplClient::Type WebImageLayerImpl::type() const
{
return WebLayerImplClient::ImageLayerType;
}
blink::WebLayer* WebImageLayerImpl::layer()
{
return m_layer;
}
void WebImageLayerImpl::setImageBitmap(const SkBitmap& bitmap)
{
if (!m_bitmap || (m_bitmap->get() && bitmap.pixelRef() && bitmap.pixelRef() == m_bitmap->get()->pixelRef()))
return;
m_bitmap->deref();
SkBitmap* bitmapCopy = new SkBitmap(bitmap);
m_bitmap = new cc::SkBitmapRefWrap();
m_bitmap->set(bitmapCopy);
m_bitmap->ref();
//m_layer->setNeedsFullTreeSync();
}
void WebImageLayerImpl::updataAndPaintContents(blink::WebCanvas* canvas, const blink::IntRect& clip)
{
}
void WebImageLayerImpl::recordDraw(cc::RasterTaskGroup* taskGroup)
{
if (m_bitmap->get()) {
taskGroup->postImageLayerAction(m_layer->id(), m_bitmap);
}
}
void WebImageLayerImpl::drawToCanvas(blink::WebCanvas* canvas, const blink::IntRect& clip)
{
// if (m_bitmap)
// canvas->drawBitmap(*m_bitmap, 0, 0, nullptr);
}
void WebImageLayerImpl::setNearestNeighbor(bool)
{
}
} // cc_blink | 23.125 | 112 | 0.709189 | wenfeifei |
a6adfa6e27e6b2123e558f1ee48dd615f645df48 | 794 | hpp | C++ | inst/include/GcAllocationCallback.hpp | PRL-PRG/lightr | 832102076f1a19ca9cc8784d83ec5a5c43543048 | [
"MIT"
] | 4 | 2020-06-11T14:58:55.000Z | 2021-10-18T20:19:15.000Z | inst/include/GcAllocationCallback.hpp | PRL-PRG/lightr | 832102076f1a19ca9cc8784d83ec5a5c43543048 | [
"MIT"
] | 42 | 2020-06-29T18:13:52.000Z | 2020-09-29T09:55:12.000Z | inst/include/GcAllocationCallback.hpp | PRL-PRG/lightr | 832102076f1a19ca9cc8784d83ec5a5c43543048 | [
"MIT"
] | 1 | 2021-02-18T13:26:05.000Z | 2021-02-18T13:26:05.000Z | #ifndef INSTRUMENTR_GC_ALLOCATION_CALLBACK_HPP
#define INSTRUMENTR_GC_ALLOCATION_CALLBACK_HPP
#include "Callback.hpp"
#include "Application.hpp"
namespace instrumentr {
class Context;
using ContextSPtr = std::shared_ptr<Context>;
class GcAllocationCallback: public Callback {
public:
GcAllocationCallback(void* function, bool is_r_callback)
: Callback(Type::GcAllocation, function, is_r_callback) {
}
void
invoke(ContextSPtr context, ApplicationSPtr application, SEXP r_object);
static void initialize();
static void finalize();
static SEXP get_class();
private:
static SEXP class_;
};
using GcAllocationCallbackSPtr = std::shared_ptr<GcAllocationCallback>;
} // namespace instrumentr
#endif /* INSTRUMENTR_GC_ALLOCATION_CALLBACK_HPP */
| 21.459459 | 76 | 0.761965 | PRL-PRG |
a6b09878f37037b5ea1c09c181a35c575384d7e7 | 5,974 | cpp | C++ | 38_FILE_IO/main.cpp | CrispenGari/cool-cpp | bcbf9e0df7af07f8b12aa554fd15d977ecb47f60 | [
"MIT"
] | null | null | null | 38_FILE_IO/main.cpp | CrispenGari/cool-cpp | bcbf9e0df7af07f8b12aa554fd15d977ecb47f60 | [
"MIT"
] | null | null | null | 38_FILE_IO/main.cpp | CrispenGari/cool-cpp | bcbf9e0df7af07f8b12aa554fd15d977ecb47f60 | [
"MIT"
] | null | null | null | #include <cstdlib>
using namespace std;
#include <iostream>
#include <string>
#include <cmath> // you can include algorithm #include <algorithm>
#include <algorithm>
#include <fstream>
/*
A file contains a record list of the following students
Name Surname StudentNo Test1 Test2 Prac1 Prac2
(populate the file with candidates of your choice)
1. Computer the average for each test and prac and display the results in an external file
2. Find the average mark for each student
3. Determine the students with pass mark and display the results on the screen (pass mark is
determined by average of both test and prac to be more or equal to 55)
4. How many students have distinctions?
*/
// An average function
int average(int total_marks, int number_of_test_or_assignment);
// The function that detemines if the student has a distinction or not
bool countDistinctions(int mark);
// a function that detemines passing or failing of student
bool passOrFail(int average_test_mark, int average_prac_mark);
// a function that writes data to files
void writtingToAFile(ofstream *filewriteObject, string name,
string surname, int stud_no, int test1, int test2, int prac1,
int prac2, int average_test, int average_prac);
int main(void)
{
// passing a file path to the string variable path as a constructor
string name, surname;
int student_no, test1, test2, prac1, prac2, avg_test, avg_pract;
string path("students.txt"); // same as string path = "students.txt"
string path1("average.txt");
string path3("marks.txt");
ifstream fileObjectRead(path);
ofstream fileObjectWrite(path1);
ofstream fileObjectWriteAverageMarks(path3);
if (fileObjectWrite.is_open())
{
fileObjectWrite << "STUDENTS AVERAGE MARKS\n";
fileObjectWrite << "name surname studentNo test1 test2 prac1 prac2 averageTest averagePrac\n";
}
else
{
cout << "Can not write to a closed file!!\a" << endl;
}
/*CHECK IF THE FILE IS OPEN*/
if (fileObjectRead.is_open())
{
int test = 0, practicals = 0;
// Qn 1 writting average marks to a file average from a file students
while (fileObjectRead >> name >> surname >> student_no >> test1 >> test2 >> prac1 >> prac2)
{
test = test1 + test2;
practicals = prac1 + prac2;
if (fileObjectWrite.is_open() && fileObjectWriteAverageMarks.is_open())
{
// write to the average file qn1
writtingToAFile(&fileObjectWrite, name, surname,
student_no, test1, test2, prac1, prac2, average(test, 2), average(practicals, 2));
// Qn2 write to the marks file
writtingToAFile(&fileObjectWriteAverageMarks, name, surname,
student_no, test1, test2, prac1, prac2, average(test, 2), average(practicals, 2));
}
// restore the marks
test = 0;
practicals = 0;
}
cout << "Qn1. THE AVERAGE MARKS OF TEST AND PRACTICAL IS NOW IN A FILE NAMED: " << path1 << endl
<< endl;
cout << "Qn2. THE AVERAGE MARKS OF TEST AND PRACTICAL FOR EACH STUDENT IS WRITTEN IN A FILE NAMED: " << path3 << endl
<< endl;
/*
while (!fileObjectRead.eof()){
// do something with the file data
}
*/
}
else
{
cout << "Can not read a closed file" << endl;
}
// Qn3 I can read the students average marks from a created file average
cout << "Qn3. THE STUDENTS WHO HAVE PASSED!!" << endl;
cout << "name surname studentNo avgTest avgPrac PASS/FAIL\n";
// We must close the stream we want to read before reading it
fileObjectWriteAverageMarks.close();
ifstream fileObjectReadPassed(path3);
int count_passed_with_Distictions = 0;
if (fileObjectReadPassed.is_open())
{
while (fileObjectReadPassed >> name >> surname >> student_no >>
test1 >> test2 >> prac1 >> prac2 >> avg_test >> avg_pract)
{
string passed_or_fail = "FAIL";
// call the function pass or fail to detemine for us
passed_or_fail = passOrFail(avg_test, avg_pract) ? "PASS" : "FAIL";
// Qn4. conting the number of people with distinctions based on a condition mark >=75
int mark = .6 * avg_test + .4 * avg_pract; // ceil() round up the number
countDistinctions(mark) && count_passed_with_Distictions++;
cout << name << "\t" << surname << "\t" << student_no << "\t"
<< avg_test << "\t" << avg_pract << "\t" << passed_or_fail << "\n";
}
}
else
{
cout << "CAN NOT READ AVERAGE MARKS TO A CLOSED FILE!!" << endl;
}
cout << "\nQn4. THE STUDENTS WHO HAVE PASSED WITH DISTINCTIONS (mark>=75) ARE: " << count_passed_with_Distictions << endl;
// Free up memory
fileObjectRead.close();
fileObjectWrite.close();
fileObjectReadPassed.close();
return 0;
}
int average(int total_marks, int number_of_test_or_assignment)
{
return total_marks / number_of_test_or_assignment;
}
bool countDistinctions(int mark)
{
// a positive mark by abs() function from the <cmath> or <algorithm>
return abs(mark) >= 75;
}
bool passOrFail(int average_test_mark, int average_prac_mark)
{
// for a student to pass these av_prac and av_test should be nore or equal to 55,
return average_test_mark >= 55 && average_prac_mark >= 55;
}
void writtingToAFile(ofstream *filewriteObject, string name,
string surname, int stud_no, int test1, int test2, int prac1,
int prac2, int average_test, int average_prac)
{
*filewriteObject << name << "\t" << surname << "\t" << stud_no << "\t" << test1 << "\t" << test2 << "\t" << prac1 << "\t" << prac2 << "\t"
<< average_test << "\t" << average_prac << "\n";
}
| 41.2 | 142 | 0.631235 | CrispenGari |
a6b2ea36193d62125126242ca030b0f227f431ec | 699 | cpp | C++ | engine samples/01_HelloWord/source/HelloWordGame.cpp | drr00t/quanticvortex | b780b0f547cf19bd48198dc43329588d023a9ad9 | [
"MIT"
] | null | null | null | engine samples/01_HelloWord/source/HelloWordGame.cpp | drr00t/quanticvortex | b780b0f547cf19bd48198dc43329588d023a9ad9 | [
"MIT"
] | null | null | null | engine samples/01_HelloWord/source/HelloWordGame.cpp | drr00t/quanticvortex | b780b0f547cf19bd48198dc43329588d023a9ad9 | [
"MIT"
] | null | null | null |
#include "HelloWordGame.h"
// QuanticVortex headers
#include "qvGameViewTypes.h"
namespace samples
{
//------------------------------------------------------------------------------------------------
HelloWordGame::HelloWordGame()
{
//CreateHumanViewCommandArgs( gameViewName);
//ConfigureInputTranslatorCommandArgs( inputTranslatorType, device, inputMap);
//LoadSceneViewCommandArgs( sceneViewFile);
// addGameView("My game Window", qv::views::GVT_GAME_VIEW_HUMAN);
}
//-----------------------------------------------------------------------------
HelloWordGame::~HelloWordGame()
{
}
//-----------------------------------------------------------------------------
}
| 27.96 | 99 | 0.463519 | drr00t |
a6b37d0dc5172895077f2121d418007934f14864 | 9,508 | cc | C++ | display/simgraph0.cc | makkrnic/simutrans-extended | 8afbbce5b88c79bfea1760cf6c7662d020757b6a | [
"Artistic-1.0"
] | null | null | null | display/simgraph0.cc | makkrnic/simutrans-extended | 8afbbce5b88c79bfea1760cf6c7662d020757b6a | [
"Artistic-1.0"
] | null | null | null | display/simgraph0.cc | makkrnic/simutrans-extended | 8afbbce5b88c79bfea1760cf6c7662d020757b6a | [
"Artistic-1.0"
] | null | null | null | /*
* This file is part of the Simutrans-Extended project under the Artistic License.
* (see LICENSE.txt)
*/
#include "../simconst.h"
#include "../sys/simsys.h"
#include "../descriptor/image.h"
#include "simgraph.h"
int large_font_height = 10;
int large_font_total_height = 11;
int large_font_ascent = 9;
KOORD_VAL tile_raster_width = 16; // zoomed
KOORD_VAL base_tile_raster_width = 16; // original
/*
* Hajo: mapping table for special-colors (AI player colors)
* to actual output format - all day mode
* 16 sets of 16 colors
*/
PIXVAL specialcolormap_all_day[256];
KOORD_VAL display_set_base_raster_width(KOORD_VAL)
{
return 0;
}
void set_zoom_factor(int)
{
}
int get_zoom_factor()
{
return 1;
}
int zoom_factor_up()
{
return false;
}
int zoom_factor_down()
{
return false;
}
void mark_rect_dirty_wc(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL)
{
}
void mark_rect_dirty_clip(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL CLIP_NUM_DEF_NOUSE)
{
}
void mark_screen_dirty()
{
}
void display_mark_img_dirty(image_id, KOORD_VAL, KOORD_VAL)
{
}
uint16 display_load_font(const char*)
{
return 1;
}
sint16 display_get_width()
{
return 0;
}
sint16 display_get_height()
{
return 0;
}
void display_set_height(KOORD_VAL)
{
}
void display_set_actual_width(KOORD_VAL)
{
}
int display_get_light()
{
return 0;
}
void display_set_light(int)
{
}
void display_day_night_shift(int)
{
}
void display_set_player_color_scheme(const int, const COLOR_VAL, const COLOR_VAL)
{
}
COLOR_VAL display_get_index_from_rgb(uint8, uint8, uint8)
{
return 0;
}
void register_image(class image_t* image)
{
image->imageid = 1;
}
void display_snapshot(int, int, int, int)
{
}
void display_get_image_offset(image_id image, KOORD_VAL *xoff, KOORD_VAL *yoff, KOORD_VAL *xw, KOORD_VAL *yw)
{
if (image < 2) {
// initialize offsets with dummy values
*xoff = 0;
*yoff = 0;
*xw = 0;
*yw = 0;
}
}
void display_get_base_image_offset(image_id image, scr_coord_val& xoff, scr_coord_val& yoff, scr_coord_val& xw, scr_coord_val& yw)
{
if (image < 2) {
// initialize offsets with dummy values
xoff = 0;
yoff = 0;
xw = 0;
yw = 0;
}
}
/*
void display_set_base_image_offset(unsigned, KOORD_VAL, KOORD_VAL)
{
}
*/
clip_dimension display_get_clip_wh(CLIP_NUM_DEF_NOUSE0)
{
clip_dimension clip_rect;
clip_rect.x = 0;
clip_rect.xx = 0;
clip_rect.w = 0;
clip_rect.y = 0;
clip_rect.yy = 0;
clip_rect.h = 0;
return clip_rect;
}
void display_set_clip_wh(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL CLIP_NUM_DEF_NOUSE)
{
}
void display_push_clip_wh(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL CLIP_NUM_DEF_NOUSE)
{
}
void display_swap_clip_wh(CLIP_NUM_DEF_NOUSE0)
{
}
void display_pop_clip_wh(CLIP_NUM_DEF_NOUSE0)
{
}
void display_scroll_band(const KOORD_VAL, const KOORD_VAL, const KOORD_VAL)
{
}
void display_img_aux(const image_id, KOORD_VAL, KOORD_VAL, const signed char, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_color_img(const image_id, KOORD_VAL, KOORD_VAL, const signed char, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_base_img(const image_id, KOORD_VAL, KOORD_VAL, const signed char, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_fit_img_to_width(const image_id, sint16)
{
}
void display_img_stretch(const stretch_map_t &, scr_rect)
{
}
void display_img_stretch_blend(const stretch_map_t &, scr_rect, PLAYER_COLOR_VAL)
{
}
void display_rezoomed_img_blend(const image_id, KOORD_VAL, KOORD_VAL, const signed char, const PLAYER_COLOR_VAL, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_rezoomed_img_alpha(const image_id, const image_id, const unsigned, KOORD_VAL, KOORD_VAL, const signed char, const PLAYER_COLOR_VAL, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_base_img_blend(const image_id, KOORD_VAL, KOORD_VAL, const signed char, const PLAYER_COLOR_VAL, const int, const int CLIP_NUM_DEF_NOUSE)
{
}
void display_base_img_alpha(const image_id, const image_id, const unsigned, KOORD_VAL, KOORD_VAL, const signed char, const PLAYER_COLOR_VAL, const int, int CLIP_NUM_DEF_NOUSE)
{
}
// Knightly : variables for storing currently used image procedure set and tile raster width
display_image_proc display_normal = display_base_img;
display_image_proc display_color = display_base_img;
display_blend_proc display_blend = display_base_img_blend;
display_alpha_proc display_alpha = display_base_img_alpha;
signed short current_tile_raster_width = 0;
void display_blend_wh_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, int)
{
}
void display_vlinear_gradient_wh_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, int, int)
{
}
void display_color_img_with_tooltip(const image_id, KOORD_VAL, KOORD_VAL, sint8, const int, const int, const char* CLIP_NUM_DEF_NOUSE)
{
}
void display_fillbox_wh_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, bool)
{
}
void display_fillbox_wh_clip_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, bool CLIP_NUM_DEF_NOUSE)
{
}
void display_cylinderbar_wh_clip_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, bool CLIP_NUM_DEF_NOUSE)
{
}
void display_colorbox_with_tooltip(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, bool, const char*)
{
}
void display_veh_form_wh_clip_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, bool, uint8, uint8, bool CLIP_NUM_DEF_NOUSE)
{
}
void display_vline_wh_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, bool)
{
}
void display_vline_wh_clip_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, bool CLIP_NUM_DEF_NOUSE)
{
}
void display_array_wh(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, const COLOR_VAL *)
{
}
void display_filled_roundbox_clip(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PIXVAL, bool)
{
}
size_t get_next_char(const char*, size_t pos)
{
return pos + 1;
}
sint32 get_prev_char(const char*, sint32 pos)
{
if (pos <= 0) {
return 0;
}
return pos - 1;
}
KOORD_VAL display_get_char_width(utf16)
{
return 0;
}
KOORD_VAL display_get_char_max_width(const char*, size_t)
{
return 0;
}
unsigned short get_next_char_with_metrics(const char* &, unsigned char &, unsigned char &)
{
return 0;
}
unsigned short get_prev_char_with_metrics(const char* &, const char *const, unsigned char &, unsigned char &)
{
return 0;
}
bool has_character(utf16)
{
return false;
}
size_t display_fit_proportional(const char *, scr_coord_val, scr_coord_val)
{
return 0;
}
int display_calc_proportional_string_len_width(const char*, size_t)
{
return 0;
}
int display_text_proportional_len_clip_rgb(KOORD_VAL, KOORD_VAL, const char*, control_alignment_t, const PIXVAL, bool, sint32 CLIP_NUM_DEF_NOUSE)
{
return 0;
}
void display_outline_proportional_rgb(KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL, const char *, int)
{
}
void display_shadow_proportional_rgb(KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL, const char *, int)
{
}
void display_ddd_box_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL, bool)
{
}
void display_ddd_box_clip_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL)
{
}
void display_ddd_proportional(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL, const char *, int)
{
}
void display_ddd_proportional_clip(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, PLAYER_COLOR_VAL, PLAYER_COLOR_VAL, const char *, int CLIP_NUM_DEF_NOUSE)
{
}
int display_multiline_text_rgb(KOORD_VAL, KOORD_VAL, const char *, PLAYER_COLOR_VAL)
{
return 0;
}
void display_flush_buffer()
{
}
void display_show_pointer(int)
{
}
void display_set_pointer(int)
{
}
void display_show_load_pointer(int)
{
}
void simgraph_init(KOORD_VAL, KOORD_VAL, int)
{
}
int is_display_init()
{
return false;
}
void display_free_all_images_above(image_id)
{
}
void simgraph_exit()
{
dr_os_close();
}
void simgraph_resize(KOORD_VAL, KOORD_VAL)
{
}
void reset_textur(void *)
{
}
void display_snapshot()
{
}
void display_direct_line_rgb(const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const PLAYER_COLOR_VAL)
{
}
void display_direct_line_rgb(const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const PLAYER_COLOR_VAL)
{
}
void display_direct_line_dotted_rgb(const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const KOORD_VAL, const PLAYER_COLOR_VAL)
{
}
void display_circle_rgb(KOORD_VAL, KOORD_VAL, int, const PLAYER_COLOR_VAL)
{
}
void display_filled_circle_rgb(KOORD_VAL, KOORD_VAL, int, const PLAYER_COLOR_VAL)
{
}
int display_fluctuation_triangle_rgb(KOORD_VAL, KOORD_VAL, uint8, const bool, sint64)
{
return 0;
}
void draw_bezier_rgb(KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, KOORD_VAL, const PLAYER_COLOR_VAL, KOORD_VAL, KOORD_VAL)
{
}
void display_set_progress_text(const char *)
{
}
void display_progress(int, int)
{
}
void display_img_aligned(const image_id, scr_rect, int, int)
{
}
KOORD_VAL display_proportional_ellipse_rgb(scr_rect, const char *, int, PIXVAL, bool)
{
return 0;
}
image_id get_image_count()
{
return 0;
}
#ifdef MULTI_THREAD
void add_poly_clip(int, int, int, int, int CLIP_NUM_DEF_NOUSE)
{
}
void clear_all_poly_clip(const sint8)
{
}
void activate_ribi_clip(int CLIP_NUM_DEF_NOUSE)
{
}
#else
void add_poly_clip(int, int, int, int, int)
{
}
void clear_all_poly_clip()
{
}
void activate_ribi_clip(int)
{
}
#endif
| 19.644628 | 186 | 0.77398 | makkrnic |
a6b6a050adf667fba6d81d8838ae25b018f6311f | 4,695 | cpp | C++ | src/profiling/PeriodicCounterSelectionCommandHandler.cpp | vivint-smarthome/armnn | 6b1bf1a40bebf4cc108d39f8b8e0c29bdfc51ce1 | [
"MIT"
] | null | null | null | src/profiling/PeriodicCounterSelectionCommandHandler.cpp | vivint-smarthome/armnn | 6b1bf1a40bebf4cc108d39f8b8e0c29bdfc51ce1 | [
"MIT"
] | null | null | null | src/profiling/PeriodicCounterSelectionCommandHandler.cpp | vivint-smarthome/armnn | 6b1bf1a40bebf4cc108d39f8b8e0c29bdfc51ce1 | [
"MIT"
] | null | null | null | //
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "PeriodicCounterSelectionCommandHandler.hpp"
#include "ProfilingUtils.hpp"
#include <armnn/Types.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/format.hpp>
#include <vector>
namespace armnn
{
namespace profiling
{
void PeriodicCounterSelectionCommandHandler::ParseData(const Packet& packet, CaptureData& captureData)
{
std::vector<uint16_t> counterIds;
uint32_t sizeOfUint32 = boost::numeric_cast<uint32_t>(sizeof(uint32_t));
uint32_t sizeOfUint16 = boost::numeric_cast<uint32_t>(sizeof(uint16_t));
uint32_t offset = 0;
if (packet.GetLength() < 4)
{
// Insufficient packet size
return;
}
// Parse the capture period
uint32_t capturePeriod = ReadUint32(packet.GetData(), offset);
// Set the capture period
captureData.SetCapturePeriod(capturePeriod);
// Parse the counter ids
unsigned int counters = (packet.GetLength() - 4) / 2;
if (counters > 0)
{
counterIds.reserve(counters);
offset += sizeOfUint32;
for (unsigned int i = 0; i < counters; ++i)
{
// Parse the counter id
uint16_t counterId = ReadUint16(packet.GetData(), offset);
counterIds.emplace_back(counterId);
offset += sizeOfUint16;
}
}
// Set the counter ids
captureData.SetCounterIds(counterIds);
}
void PeriodicCounterSelectionCommandHandler::operator()(const Packet& packet)
{
ProfilingState currentState = m_StateMachine.GetCurrentState();
switch (currentState)
{
case ProfilingState::Uninitialised:
case ProfilingState::NotConnected:
case ProfilingState::WaitingForAck:
throw RuntimeException(boost::str(boost::format("Periodic Counter Selection Command Handler invoked while in "
"an wrong state: %1%")
% GetProfilingStateName(currentState)));
case ProfilingState::Active:
{
// Process the packet
if (!(packet.GetPacketFamily() == 0u && packet.GetPacketId() == 4u))
{
throw armnn::InvalidArgumentException(boost::str(boost::format("Expected Packet family = 0, id = 4 but "
"received family = %1%, id = %2%")
% packet.GetPacketFamily()
% packet.GetPacketId()));
}
// Parse the packet to get the capture period and counter UIDs
CaptureData captureData;
ParseData(packet, captureData);
// Get the capture data
uint32_t capturePeriod = captureData.GetCapturePeriod();
// Validate that the capture period is within the acceptable range.
if (capturePeriod > 0 && capturePeriod < LOWEST_CAPTURE_PERIOD)
{
capturePeriod = LOWEST_CAPTURE_PERIOD;
}
const std::vector<uint16_t>& counterIds = captureData.GetCounterIds();
// Check whether the selected counter UIDs are valid
std::vector<uint16_t> validCounterIds;
for (uint16_t counterId : counterIds)
{
// Check whether the counter is registered
if (!m_ReadCounterValues.IsCounterRegistered(counterId))
{
// Invalid counter UID, ignore it and continue
continue;
}
// The counter is valid
validCounterIds.push_back(counterId);
}
// Set the capture data with only the valid counter UIDs
m_CaptureDataHolder.SetCaptureData(capturePeriod, validCounterIds);
// Echo back the Periodic Counter Selection packet to the Counter Stream Buffer
m_SendCounterPacket.SendPeriodicCounterSelectionPacket(capturePeriod, validCounterIds);
// Notify the Send Thread that new data is available in the Counter Stream Buffer
m_SendCounterPacket.SetReadyToRead();
if (capturePeriod == 0 || validCounterIds.empty())
{
// No data capture stop the thread
m_PeriodicCounterCapture.Stop();
}
else
{
// Start the Period Counter Capture thread (if not running already)
m_PeriodicCounterCapture.Start();
}
break;
}
default:
throw RuntimeException(boost::str(boost::format("Unknown profiling service state: %1%")
% static_cast<int>(currentState)));
}
}
} // namespace profiling
} // namespace armnn
| 33.535714 | 118 | 0.61065 | vivint-smarthome |
a6bc696cea1a4154083afcd130c3edcf2c3084c4 | 1,766 | hh | C++ | libsrc/pylith/feassemble/feassemblefwd.hh | joegeisz/pylith | f74060b7b19d7e90abf8597bbe9250c96593c0ad | [
"MIT"
] | 1 | 2021-01-20T17:18:28.000Z | 2021-01-20T17:18:28.000Z | libsrc/pylith/feassemble/feassemblefwd.hh | joegeisz/pylith | f74060b7b19d7e90abf8597bbe9250c96593c0ad | [
"MIT"
] | null | null | null | libsrc/pylith/feassemble/feassemblefwd.hh | joegeisz/pylith | f74060b7b19d7e90abf8597bbe9250c96593c0ad | [
"MIT"
] | null | null | null | // -*- C++ -*-
//
// ======================================================================
//
// Brad T. Aagaard, U.S. Geological Survey
// Charles A. Williams, GNS Science
// Matthew G. Knepley, University of Chicago
//
// This code was developed as part of the Computational Infrastructure
// for Geodynamics (http://geodynamics.org).
//
// Copyright (c) 2010-2017 University of California, Davis
//
// See COPYING for license information.
//
// ======================================================================
//
/** @file libsrc/feassemble/feassemblefwd.hh
*
* @brief Forward declarations for PyLith feassemble objects.
*
* Including this header file eliminates the need to use separate
* forward declarations.
*/
#if !defined(pylith_feassemble_feassemblefwd_hh)
#define pylith_feassemble_feassemblefwd_hh
namespace pylith {
namespace feassemble {
class CellGeometry;
class GeometryLine2D;
class GeometryLine3D;
class GeometryTri2D;
class GeometryTri3D;
class GeometryQuad2D;
class GeometryQuad3D;
class GeometryTet3D;
class GeometryHex3D;
class Quadrature;
class QuadratureRefCell;
class QuadratureEngine;
class Quadrature1Din2D;
class Quadrature1Din3D;
class Quadrature2D;
class Quadrature2Din3D;
class Quadrature3D;
class Constraint;
class Integrator;
class IntegratorElasticity;
class ElasticityImplicit;
class ElasticityExplicit;
class ElasticityExplicitTet4;
class ElasticityExplicitTri3;
class IntegratorElasticityLgDeform;
class ElasticityImplicitLgDeform;
class ElasticityExplicitLgDeform;
class ElasticityImplicitCUDA;
} // feassemble
} // pylith
#endif // pylith_feassemble_feassemblefwd_hh
// End of file
| 23.236842 | 73 | 0.674972 | joegeisz |
a6cf8021e79b639784b74658b51c0fe8090e1ee8 | 2,714 | cpp | C++ | src/LedPack/gyroscope.cpp | Robert1991/LedPack | df0737120f82b83d3eeda5ca23981af161dd3113 | [
"MIT"
] | null | null | null | src/LedPack/gyroscope.cpp | Robert1991/LedPack | df0737120f82b83d3eeda5ca23981af161dd3113 | [
"MIT"
] | null | null | null | src/LedPack/gyroscope.cpp | Robert1991/LedPack | df0737120f82b83d3eeda5ca23981af161dd3113 | [
"MIT"
] | null | null | null | #include "gyroscope.h"
AccelerationMeasurementVector::AccelerationMeasurementVector(int accX, int accY, int accZ) {
this->accX = accX;
this->accY = accY;
this->accZ = accZ;
}
AccelerationMeasurementVector::AccelerationMeasurementVector() {}
AccelerationMeasurementVector AccelerationMeasurementVector::defaultVector() { return AccelerationMeasurementVector(); }
AccerlationVectorDifference AccelerationMeasurementVector::euclideanDistanceTo(AccelerationMeasurementVector otherVector) {
float euclideanDistance = sqrt(pow(accX - otherVector.accX, 2) + pow(accY - otherVector.accY, 2) + pow(accZ - otherVector.accZ, 2));
float accRatio = euclideanDistance / MAX_ACCELERATION_VECTOR_DIFFERENCE;
return AccerlationVectorDifference(euclideanDistance, accRatio);
}
bool operator==(const AccelerationMeasurementVector &lhs, const AccelerationMeasurementVector &rhs) {
return lhs.accX == rhs.accX && lhs.accY == rhs.accY && lhs.accZ == rhs.accZ;
}
bool operator!=(const AccelerationMeasurementVector &lhs, const AccelerationMeasurementVector &rhs) { return !(lhs == rhs); }
AccerlationVectorDifference::AccerlationVectorDifference(float rawDifference, float differenceRatio) {
this->rawDifference = rawDifference;
this->differenceRatio = differenceRatio;
}
int AccerlationVectorDifference::mapAccelerationRatioTo(IAccelerationRatioMapper *mapper) { return mapper->mapToInt((this->differenceRatio)); }
bool AccerlationVectorDifference::overThreshold(float rawValue) { return (this->rawDifference) > rawValue; }
bool operator==(const AccerlationVectorDifference &lhs, const AccerlationVectorDifference &rhs) {
return (fabs(lhs.differenceRatio - rhs.differenceRatio) < 0.005f) && (fabs(lhs.rawDifference - rhs.rawDifference) < 0.005f);
}
bool operator==(const AccerlationVectorDifference *lhs, const AccerlationVectorDifference &rhs) {
return (fabs(lhs->differenceRatio - rhs.differenceRatio) < 0.005f) && (fabs(lhs->rawDifference - rhs.rawDifference) < 0.005f);
}
bool operator!=(const AccerlationVectorDifference &lhs, const AccerlationVectorDifference &rhs) { return !(lhs == rhs); }
bool operator!=(const AccerlationVectorDifference *lhs, const AccerlationVectorDifference &rhs) { return !(lhs == rhs); }
Gyroscope::Gyroscope(GyroscopeWire *wire) { this->wire = wire; }
Gyroscope::Gyroscope() {}
AccelerationMeasurementVector Gyroscope::measureAcceleration() {
requestMeasurement();
int accX = wire->readNextRegister();
int accY = wire->readNextRegister();
int accZ = wire->readNextRegister();
return AccelerationMeasurementVector(accX, accY, accZ);
}
void Gyroscope::wakeUp() { wire->initialize(); }
void Gyroscope::requestMeasurement() { wire->requestMeasurement(); }
| 43.774194 | 143 | 0.779293 | Robert1991 |
a6d276d4b8a19938119a98e4bc1b7f5a2ba48330 | 4,316 | cc | C++ | tests/unit_tests/data/blocks/date_time.cc | tini2p/tini2p | 28fb4ddf69b2f191fee91a4ff349135fcff8dfe1 | [
"BSD-3-Clause"
] | 12 | 2019-01-21T07:04:30.000Z | 2021-12-06T03:35:07.000Z | tests/unit_tests/data/blocks/date_time.cc | chisa0a/tini2p | a9b6cb48dbbc8d667b081a95c720f0ff2a0f84f5 | [
"BSD-3-Clause"
] | null | null | null | tests/unit_tests/data/blocks/date_time.cc | chisa0a/tini2p | a9b6cb48dbbc8d667b081a95c720f0ff2a0f84f5 | [
"BSD-3-Clause"
] | 5 | 2019-02-07T23:08:37.000Z | 2021-12-06T03:35:08.000Z | /* Copyright (c) 2019, tini2p
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <catch2/catch.hpp>
#include "src/data/blocks/date_time.h"
namespace meta = tini2p::meta::block;
using tini2p::time::now_s;
using tini2p::data::DateTimeBlock;
struct DateTimeBlockFixture
{
DateTimeBlock block;
};
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock has a block ID",
"[block]")
{
REQUIRE(block.type() == DateTimeBlock::Type::DateTime);
}
TEST_CASE_METHOD(DateTimeBlockFixture, "DateTimeBlock has a size", "[block]")
{
REQUIRE(block.data_size() == DateTimeBlock::TimestampLen);
REQUIRE(
block.size() == DateTimeBlock::HeaderLen + DateTimeBlock::TimestampLen);
REQUIRE(block.size() == block.buffer().size());
}
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock has a timestamp",
"[block]")
{
REQUIRE(block.timestamp());
REQUIRE(tini2p::time::check_lag_s(block.timestamp()));
}
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock serializes and deserializes from the buffer",
"[block]")
{
// set valid DateTime block parameters
const auto tmp_ts = now_s();
// serialize to buffer
REQUIRE_NOTHROW(block.serialize());
// deserialize from buffer
REQUIRE_NOTHROW(block.deserialize());
REQUIRE(block.type() == DateTimeBlock::Type::DateTime);
REQUIRE(block.data_size() == DateTimeBlock::TimestampLen);
REQUIRE(block.timestamp() == tmp_ts);
REQUIRE(
block.size() == DateTimeBlock::HeaderLen + DateTimeBlock::TimestampLen);
REQUIRE(block.buffer().size() == block.size());
}
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock fails to deserialize invalid ID",
"[block]")
{
// serialize a valid block
REQUIRE_NOTHROW(block.serialize());
// invalidate the block ID
++block.buffer()[DateTimeBlock::TypeOffset];
REQUIRE_THROWS(block.deserialize());
block.buffer()[DateTimeBlock::TypeOffset] -= 2;
REQUIRE_THROWS(block.deserialize());
}
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock fails to deserialize invalid size",
"[block]")
{
// invalidate the size
++block.buffer()[DateTimeBlock::SizeOffset];
REQUIRE_THROWS(block.deserialize());
block.buffer()[DateTimeBlock::SizeOffset] -= 2;
REQUIRE_THROWS(block.deserialize());
}
TEST_CASE_METHOD(
DateTimeBlockFixture,
"DateTimeBlock fails to deserialize invalid timestamp",
"[block]")
{
using tini2p::meta::time::MaxLagDelta;
// serialize a valid block
REQUIRE_NOTHROW(block.serialize());
// invalidate the timestamp (lowerbound)
block.buffer()[DateTimeBlock::TimestampOffset] -= MaxLagDelta + 1;
REQUIRE_THROWS(block.deserialize());
// invalidate the timestamp (upperbound)
block.buffer()[DateTimeBlock::TimestampOffset] = now_s() + (MaxLagDelta + 1);
REQUIRE_THROWS(block.deserialize());
}
| 31.275362 | 81 | 0.734013 | tini2p |
a6d4c69a57df9586374cc5ccea56d4b43a6223ff | 9,929 | cpp | C++ | multisense_ros/src/config.cpp | davidirobinson/multisense_ros2 | 87aa8dd64d3f380ffbff2483a32d0362c27dff5a | [
"MIT"
] | null | null | null | multisense_ros/src/config.cpp | davidirobinson/multisense_ros2 | 87aa8dd64d3f380ffbff2483a32d0362c27dff5a | [
"MIT"
] | null | null | null | multisense_ros/src/config.cpp | davidirobinson/multisense_ros2 | 87aa8dd64d3f380ffbff2483a32d0362c27dff5a | [
"MIT"
] | 1 | 2021-07-18T23:33:32.000Z | 2021-07-18T23:33:32.000Z | /**
* @file config.cpp
*
* Copyright 2020
* Carnegie Robotics, LLC
* 4501 Hatfield Street, Pittsburgh, PA 15201
* http://www.carnegierobotics.com
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Carnegie Robotics, LLC nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL CARNEGIE ROBOTICS, LLC BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**/
#include <multisense_ros/config.h>
#include <multisense_ros/parameter_utilities.h>
namespace multisense_ros {
Config::Config(const std::string& node_name, crl::multisense::Channel* driver):
Node(node_name),
driver_(driver)
{
if (const auto status = driver_->getDeviceInfo(device_info_); status != crl::multisense::Status_Ok)
{
RCLCPP_ERROR(get_logger(), "Config: failed to query device info: %s",
crl::multisense::Channel::statusString(status));
return;
}
if (device_info_.lightingType != 0)
{
if (const auto status = driver_->getLightingConfig(lighting_config_); status != crl::multisense::Status_Ok)
{
RCLCPP_ERROR(get_logger(), "Config: failed to query lighting info: %s",
crl::multisense::Channel::statusString(status));
return;
}
}
if (const auto status = driver_->getTransmitDelay(transmit_delay_); status != crl::multisense::Status_Ok)
{
RCLCPP_ERROR(get_logger(), "Config: failed to query transmit delay: %s",
crl::multisense::Channel::statusString(status));
return;
}
paramter_handle_ = add_on_set_parameters_callback(std::bind(&Config::parameterCallback, this, std::placeholders::_1));
//
// Transmit delay
rcl_interfaces::msg::IntegerRange transmit_delay_range;
transmit_delay_range.set__from_value(0)
.set__to_value(500)
.set__step(1);
rcl_interfaces::msg::ParameterDescriptor transmit_delay_desc;
transmit_delay_desc.set__name("desired_transmit_delay")
.set__type(rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER)
.set__description("delay in ms before multisense sends data")
.set__integer_range({transmit_delay_range});
declare_parameter("desired_transmit_delay", 0, transmit_delay_desc);
if (device_info_.hardwareRevision != crl::multisense::system::DeviceInfo::HARDWARE_REV_MULTISENSE_ST21)
{
if (device_info_.lightingType != 0)
{
//
// Lighting
rcl_interfaces::msg::ParameterDescriptor lighting_desc;
lighting_desc.set__name("lighting")
.set__type(rcl_interfaces::msg::ParameterType::PARAMETER_BOOL)
.set__description("enable external lights");
declare_parameter("lighting", false, lighting_desc);
//
// Flash
rcl_interfaces::msg::ParameterDescriptor flash_desc;
flash_desc.set__name("flash")
.set__type(rcl_interfaces::msg::ParameterType::PARAMETER_BOOL)
.set__description("strobe lights with each image exposure");
declare_parameter("flash", false, flash_desc);
//
// LED duty cycle
rcl_interfaces::msg::FloatingPointRange led_duty_cycle_range;
led_duty_cycle_range.set__from_value(0.0)
.set__to_value(1.0)
.set__step(0.01);
rcl_interfaces::msg::ParameterDescriptor led_duty_cycle_desc;
led_duty_cycle_desc.set__name("led_duty_cycle")
.set__type(rcl_interfaces::msg::ParameterType::PARAMETER_DOUBLE)
.set__description("LED duty cycle when lights enabled")
.set__floating_point_range({led_duty_cycle_range});
declare_parameter("led_duty_cycle", 0.0, led_duty_cycle_desc);
}
//
// Network time sync
rcl_interfaces::msg::ParameterDescriptor network_time_sync_desc;
network_time_sync_desc.set__name("network_time_sync")
.set__type(rcl_interfaces::msg::ParameterType::PARAMETER_BOOL)
.set__description("run basic time sync between MultiSense and host");
declare_parameter("network_time_sync", true, network_time_sync_desc);
}
}
Config::~Config()
{
}
rcl_interfaces::msg::SetParametersResult Config::parameterCallback(const std::vector<rclcpp::Parameter>& parameters)
{
rcl_interfaces::msg::SetParametersResult result;
result.set__successful(true);
bool update_lighting = false;
for (const auto ¶meter : parameters)
{
const auto type = parameter.get_type();
if (type == rclcpp::ParameterType::PARAMETER_NOT_SET)
{
continue;
}
const auto name = parameter.get_name();
if (name == "desired_transmit_delay")
{
if (type != rclcpp::ParameterType::PARAMETER_DOUBLE && type != rclcpp::ParameterType::PARAMETER_INTEGER)
{
return result.set__successful(false).set__reason("invalid transmission delay type");
}
const auto value = get_as_number<int>(parameter);
if (transmit_delay_.delay != value)
{
auto delay = transmit_delay_;
delay.delay = value;
if (const auto status = driver_->setTransmitDelay(delay); status != crl::multisense::Status_Ok)
{
return result.set__successful(false).set__reason(crl::multisense::Channel::statusString(status));
}
transmit_delay_ = std::move(delay);
}
}
else if (name == "lighting")
{
if (type != rclcpp::ParameterType::PARAMETER_BOOL)
{
return result.set__successful(false).set__reason("invalid lighting type");
}
const auto value = parameter.as_bool();
if (lighting_enabled_ != value)
{
lighting_enabled_ = value;
update_lighting = true;
}
}
else if(name == "flash")
{
if (type != rclcpp::ParameterType::PARAMETER_BOOL)
{
return result.set__successful(false).set__reason("invalid flash type");
}
const auto value = parameter.as_bool();
if (lighting_config_.getFlash() != value)
{
lighting_config_.setFlash(value);
update_lighting = true;
}
}
else if(name == "led_duty_cycle")
{
if (type != rclcpp::ParameterType::PARAMETER_DOUBLE && type != rclcpp::ParameterType::PARAMETER_INTEGER)
{
return result.set__successful(false).set__reason("invalid led duty cycle type");
}
const auto value = get_as_number<double>(parameter);
if (lighting_config_.getDutyCycle(0) != value)
{
lighting_config_.setDutyCycle(value);
update_lighting = true;
}
}
else if(name == "network_time_sync")
{
if (type != rclcpp::ParameterType::PARAMETER_BOOL)
{
return result.set__successful(false).set__reason("invalid network time sync type");
}
if (const auto status = driver_->networkTimeSynchronization(parameter.as_bool());
status != crl::multisense::Status_Ok)
{
return result.set__successful(false).set__reason(crl::multisense::Channel::statusString(status));
}
}
}
if (update_lighting)
{
auto config = lighting_config_;
config.setFlash(lighting_enabled_ ? config.getFlash() : false);
config.setDutyCycle(lighting_enabled_ ? config.getDutyCycle(0) : 0.0);
if (const auto status = driver_->setLightingConfig(config); status != crl::multisense::Status_Ok)
{
if (status == crl::multisense::Status_Unsupported)
{
return result.set__successful(false).set__reason("lighting not supported");
}
else
{
return result.set__successful(false).set__reason(crl::multisense::Channel::statusString(status));
}
}
}
return result;
}
}
| 38.785156 | 122 | 0.613758 | davidirobinson |
a6d4ec99bda3d0d817acb8e21c50ee77d13f547c | 5,175 | cpp | C++ | src/DS3231/DS3231.cpp | MarkMan0/STM32-Serial-Parser | 3ed62f3876d0859cbb4382af51b766815a9d994a | [
"BSD-3-Clause"
] | null | null | null | src/DS3231/DS3231.cpp | MarkMan0/STM32-Serial-Parser | 3ed62f3876d0859cbb4382af51b766815a9d994a | [
"BSD-3-Clause"
] | null | null | null | src/DS3231/DS3231.cpp | MarkMan0/STM32-Serial-Parser | 3ed62f3876d0859cbb4382af51b766815a9d994a | [
"BSD-3-Clause"
] | null | null | null | #include "DS3231/DS3231.h"
#include "main.h"
#include "i2c.h"
#include "utils.h"
#include "stdio.h"
#include "uart.h"
#include "cmsis_os.h"
/**
* @brief DS3231 Hardware description
*
*/
namespace DS3231Reg {
/**
* @brief DS3231 register addresses
*
*/
enum reg {
SECONDS,
MINUTES,
HOURS,
DAY,
DATE,
MONTH,
YEAR,
ALARM_1_SECONDS,
ALARM_1_MINUTES,
ALARM_1_HOURS,
ALARM_1_DAY_DATE,
ALARM_2_MINUTES,
ALARM_2_HOURS,
ALARM_2_DAY_DATE,
CONTROL,
CONTROL_STATUS,
AGING_OFFSET,
TEMP_MSB,
TEMP_LSB,
REGISTER_END,
};
/**
* @brief Masks to hel manipulate registers
*
*/
enum mask {
MASK_SECONDS = 0b1111,
MASK_10_SECONDS = 0b1110000,
MASK_MINUTES = 0b1111,
MASK_10_MINUTES = 0b1110000,
MASK_HOURS = 0b1111,
MASK_10_HOUR = 0b10000,
MASK_AM_PM_20_HOUR = 0b100000,
MASK_12_24 = 0b1000000,
MASK_DAY = 0b111,
MASK_DATE = 0b1111,
MASK_10_DATE = 0b110000,
MASK_MONTH = 0b1111,
MASK_10_MONTH = 0b10000,
MASK_CENTURY = 0b10000000,
MASK_YEAR = 0b1111,
MASK_10_YEAR = 0b11110000,
MASK_N_EOSC = 1 << 7,
MASK_BBSQW = 1 << 6,
MASK_CONV = 1 << 5,
MASK_RS2 = 1 << 4,
MASK_RS1 = 1 << 3,
MASK_INTCN = 1 << 2,
MASK_A2IE = 1 << 1,
MASK_A1IE = 1 << 0,
MASK_OSF = 1 << 7,
MASK_EN32KHZ = 1 << 3,
MASK_BSY = 1 << 2,
MASK_A2F = 1 << 1,
MASK_A1F = 1 << 0,
};
} // namespace DS3231Reg
using namespace DS3231Reg;
constexpr uint8_t DS3231::dev_address_;
/**
* @brief Used as default value
*
*/
static constexpr DS3231::time valid_time{ .seconds = 0,
.minutes = 0,
.hours = 0,
.day = 1,
.date = 1,
.month = 1,
.am_pm = DS3231::AM_PM_UNUSED,
.year = 2000 };
void DS3231::report_all_registers() {
uint8_t buff[REGISTER_END];
{
auto lck = i2c.get_lock();
if (!lck.lock()) {
return;
}
if (!i2c.read_register(dev_address_, SECONDS, buff, REGISTER_END)) {
return;
}
}
for (uint8_t i = 0; i < REGISTER_END; ++i) {
uart2.printf("buff %d, val: %d", i, buff[i]);
}
}
bool DS3231::get_time(time& t) {
uint8_t buff[7];
buff[0] = SECONDS;
{
auto lck = i2c.get_lock();
if (!lck.lock()) {
return false;
}
if (!i2c.read_register(dev_address_, SECONDS, buff, 7)) {
return false;
}
}
t = valid_time;
t.seconds = (buff[0] & MASK_SECONDS) + 10 * ((buff[0] & MASK_10_SECONDS) >> 4);
t.minutes = (buff[1] & MASK_MINUTES) + 10 * ((buff[1] & MASK_10_MINUTES) >> 4);
if (buff[2] & MASK_12_24) {
t.am_pm = (buff[2] & MASK_AM_PM_20_HOUR) ? AM_PM::PM : AM_PM::AM;
} else {
t.am_pm = AM_PM::AM_PM_UNUSED;
}
t.hours = (buff[2] & MASK_HOURS) + 10 * (!!(buff[2] & MASK_10_HOUR));
if (t.am_pm == AM_PM::AM_PM_UNUSED) {
t.hours += 20 * (!!(buff[2] & MASK_AM_PM_20_HOUR));
}
t.day = buff[3] & MASK_DAY;
t.date = (buff[4] & MASK_DATE) + 10 * ((buff[4] & MASK_10_DATE) >> 4);
t.month = (buff[5] & MASK_MONTH) + 10 * (!!(buff[5] & MASK_10_MONTH));
t.year = 2000 + (buff[6] & MASK_YEAR) + 10 * ((buff[6] & MASK_10_YEAR) >> 4);
return true;
}
bool DS3231::set_time(time& t) {
uint8_t buff[7];
using utils::is_within;
if (!is_within(t.seconds, 0, 59)) return false;
if (!is_within(t.minutes, 0, 59)) return false;
if (!is_within(t.hours, 0, 23)) return false;
if (!is_within(t.day, 1, 7)) return false;
if (!is_within(t.date, 1, 31)) return false;
if (!is_within(t.month, 1, 12)) return false;
if (!is_within(t.am_pm, AM_PM_UNUSED, AM_PM::PM)) return false;
if (!is_within(t.year, 2000, 2099)) return false;
buff[0] = ((t.seconds / 10) << 4) | ((t.seconds % 10) & MASK_SECONDS);
buff[1] = ((t.minutes / 10) << 4) | ((t.minutes % 10) & MASK_MINUTES);
buff[2] = 0;
if (t.am_pm == AM_PM::AM_PM_UNUSED) {
if (t.hours >= 20) {
buff[2] |= MASK_AM_PM_20_HOUR;
}
} else {
buff[2] |= MASK_12_24;
if (t.am_pm == AM_PM::PM) {
buff[2] |= MASK_AM_PM_20_HOUR;
}
}
if (t.hours >= 10 && t.hours < 20) {
buff[2] |= MASK_10_HOUR;
}
buff[2] |= (t.hours % 10) & MASK_HOURS;
buff[3] = t.day & MASK_DAY;
buff[4] = ((t.date / 10) << 4) | ((t.date % 10) & MASK_DATE);
buff[5] = (t.month % 10) & MASK_MONTH;
if (t.month >= 10) {
buff[5] |= MASK_10_MONTH;
}
buff[6] = ((t.year - 2000) / 10) << 4;
buff[6] |= (t.year % 10) & MASK_YEAR;
return i2c.get_lock().lock() && i2c.write_register(dev_address_, SECONDS, buff, 7);
}
void DS3231::report_time(const time& t) {
uart2.printf("%2d.%2d.%4d %2d:%2d:%2d", t.date, t.month, t.year, t.hours, t.minutes, t.seconds);
static constexpr const char* strs[] = {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
if (!utils::is_within(t.day, 1, 7)) {
return;
}
uart2.printf("DOW: %s", strs[t.day - 1]);
}
DS3231 rtc;
| 23.847926 | 98 | 0.551304 | MarkMan0 |
a6d8cddca771e3fa045fed5f69dda19f1393dd3a | 2,931 | cpp | C++ | src/Game.cpp | RHUL-CS-Projects/towersAndMuskets | 6679857813e6bcd55e3bfc4f587e23e76da6e603 | [
"MIT"
] | 8 | 2017-04-01T13:27:27.000Z | 2019-03-23T14:44:15.000Z | src/Game.cpp | RHUL-CS-Projects/towersAndMuskets | 6679857813e6bcd55e3bfc4f587e23e76da6e603 | [
"MIT"
] | null | null | null | src/Game.cpp | RHUL-CS-Projects/towersAndMuskets | 6679857813e6bcd55e3bfc4f587e23e76da6e603 | [
"MIT"
] | null | null | null | #include <Game.h>
#include <irrlicht/irrlicht.h>
#include <EventReceiver.h>
#include <chrono>
#include <sfml/SFML/Window.hpp>
#include <StateMainMenu.h>
#include <DebugValues.h>
using namespace std;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
using namespace chrono;
using namespace sf;
Game Game::game;
void Game::init() {
rendManager.init(L"Tower Defence");
device = rendManager.getDevice();
driver = rendManager.getDriver();
smgr = rendManager.getSceneManager();
guienv = rendManager.getGUIEnvironment();
device->setResizable(false);
SAppContext context;
context.device = device;
EventReceiver* eventReceiver = new EventReceiver(context);
device->setEventReceiver(eventReceiver);
pushState(new StateMainMenu());
}
void Game::run() {
Clock gameClock;
double ticksPerSecond = 60;
double tickTime = 1000.0 / ticksPerSecond * 1000.0;
double maxFrameSkip = 10;
double nextTick = gameClock.getElapsedTime().asMicroseconds();
double currentTime;
int loops = 0;
int tickCounter = 0;
int frameCounter = 0;
double updateTime = gameClock.getElapsedTime().asMicroseconds();
while (device->run()) {
currentTime = gameClock.getElapsedTime().asMicroseconds();
loops = 0;
while (currentTime >= nextTick && loops < maxFrameSkip) {
// Update game
if (stateStack.size() > 0)
updateStates();
nextTick += tickTime;
loops++;
tickCounter++;
}
//objManager.drawSystems(0);
// Render game
if (stateStack.size() > 0)
renderStates();
frameCounter++;
if (currentTime - updateTime >= 1000000.0) {
if (DebugValues::PRINT_FPS)
cout << "Ticks: " << tickCounter << ", Frames: " << frameCounter << endl;
frameCounter = 0;
tickCounter = 0;
updateTime += 1000000.0;//currentTime - ((currentTime - updateTime) - 1000);
}
}
}
void Game::dispose() {
resources.freeSounds();
device->drop();
}
void Game::updateStates() {
for (GameState* state : stateStack) {
state->update();
if (!state->transparentUpdate)
break;
}
}
void Game::renderStates() {
driver->beginScene(true, true, irr::video::SColor(255,0,0,0));
int bottom = 0;
for (int i = 0; i < stateStack.size(); i++) {
if (stateStack.at(i)->transparentDraw)
bottom++;
else
break;
}
for (int i = bottom; i >= 0; i--) {
stateStack.at(i)->render(driver);
}
driver->endScene();
}
void Game::pushState ( GameState* state ) {
stateStack.insert(stateStack.begin(), state);
}
void Game::popState() {
GameState* current = currentState();
stateStack.erase(stateStack.begin());
delete current;
}
void Game::popStates ( int num ) {
for (int i = 0; i < num; i++) {
popState();
}
}
ObjectManager* Game::getObjMgr() {
return &objManager;
}
RenderManager* Game::getRendMgr() {
return &rendManager;
}
GameState* Game::currentState() {
return stateStack.front();
}
| 20.075342 | 79 | 0.67622 | RHUL-CS-Projects |
a6de37a6041bada1a9398b09a16b208d800697b4 | 31,560 | cpp | C++ | Source/Scene/RNVoxelEntity.cpp | uberpixel/Rayne | 94f601561aedfc3200e67ff9522f64fbc5ca4d8c | [
"MIT"
] | 13 | 2020-08-08T11:57:05.000Z | 2022-03-10T17:29:19.000Z | Source/Scene/RNVoxelEntity.cpp | uberpixel/Rayne | 94f601561aedfc3200e67ff9522f64fbc5ca4d8c | [
"MIT"
] | 1 | 2022-03-10T17:35:28.000Z | 2022-03-10T18:21:57.000Z | Source/Scene/RNVoxelEntity.cpp | uberpixel/Rayne | 94f601561aedfc3200e67ff9522f64fbc5ca4d8c | [
"MIT"
] | 3 | 2020-08-08T14:22:34.000Z | 2021-05-15T21:12:17.000Z | //
// RNVoxelEntity.cpp
// Rayne
//
// Copyright 2020 by Überpixel. All rights reserved.
// Unauthorized use is punishable by torture, mutilation, and corona.
//
#include "RNVoxelEntity.h"
namespace RN
{
RNDefineMeta(VoxelEntity, SceneNode)
VoxelEntity::VoxelEntity(uint32 resolutionX, uint32 resolutionY, uint32 resolutionZ) :
_resolutionX(resolutionX),
_resolutionY(resolutionY),
_resolutionZ(resolutionZ),
_surface(127),
_mesh(nullptr),
_material(nullptr)
{
_voxels = new Point[_resolutionX * _resolutionY * _resolutionZ];
Renderer *renderer = Renderer::GetActiveRenderer();
_drawable = renderer->CreateDrawable();
}
VoxelEntity::~VoxelEntity()
{
delete[] _voxels;
SafeRelease(_material);
SafeRelease(_mesh);
Renderer *renderer = Renderer::GetActiveRenderer();
renderer->DeleteDrawable(_drawable);
}
void VoxelEntity::SetMaterial(Material *material)
{
SafeRelease(_material);
_material = SafeRetain(material);
}
void VoxelEntity::SetVoxel(uint32 x, uint32 y, uint32 z, const Point &voxel)
{
if(x >= _resolutionX || y >= _resolutionY || z >= _resolutionZ)
return;
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z] = voxel;
}
uint8 VoxelEntity::GetVoxel(uint32 x, uint32 y, uint32 z) const
{
if(x >= _resolutionX || y >= _resolutionY || z >= _resolutionZ)
return 0;
return _voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z].density;
}
uint8 VoxelEntity::GetVoxel(const Vector3 &position) const
{
if(position.x < 0 || position.y < 0 || position.z < 0 || position.x >= _resolutionX || position.y >= _resolutionY || position.z >= _resolutionZ)
return 0;
return _voxels[static_cast<uint32>(position.x) * _resolutionY * _resolutionZ + static_cast<uint32>(position.y) * _resolutionZ + static_cast<uint32>(position.z)].density;
}
void VoxelEntity::ApplyBlur(Vector3 from, Vector3 to, uint8 radius)
{
if(from.GetMin() < 0.0f)
from = Vector3(0.0f);
if(to.GetMax() < 0.0f)
to = Vector3(0.0f);
if(from.x >= _resolutionX)
from.x = _resolutionX;
if(from.y >= _resolutionY)
from.y = _resolutionY;
if(from.z >= _resolutionZ)
from.z = _resolutionZ;
if(to.x >= _resolutionX)
to.x = _resolutionX;
if(to.y >= _resolutionY)
to.y = _resolutionY;
if(to.z >= _resolutionZ)
to.z = _resolutionZ;
if(from == Vector3(0.0f) && to == Vector3(0.0f))
to = Vector3(_resolutionX - 1.0f, _resolutionY - 1.0f, _resolutionZ - 1.0f);
uint8 diameter = radius * 2 + 1;
for(int x = from.x; x <= to.x; x++)
{
for(int y = from.y; y <= to.y; y++)
{
for(int z = from.z; z <= to.z; z++)
{
uint32 density = 0;
for(int k = -radius; k <= radius; k++)
{
if((x + k) >= 0 && (x + k) < _resolutionX)
density += _voxels[(x + k) * _resolutionY * _resolutionZ + y * _resolutionZ + z].density;
}
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z].smoothDensity = density / diameter;
}
}
}
for(int x = from.x; x <= to.x; x++)
{
for(int y = from.y; y <= to.y; y++)
{
for(int z = from.z; z <= to.z; z++)
{
uint32 density = 0;
for(int k = -radius; k <= radius; k++)
{
if((y + k) >= 0 && (y + k) < _resolutionY)
density += _voxels[x * _resolutionY * _resolutionZ + (y + k) * _resolutionZ + z].smoothDensity;
}
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z].smoothDensity = density / diameter;
}
}
}
for(int x = from.x; x <= to.x; x++)
{
for(int y = from.y; y <= to.y; y++)
{
for(int z = from.z; z <= to.z; z++)
{
uint32 density = 0;
for(int k = -radius; k <= radius; k++)
{
if((z + k) >= 0 && (z + k) < _resolutionZ)
density += _voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z + k].smoothDensity;
}
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z].smoothDensity = density / diameter;
}
}
}
}
uint8 VoxelEntity::GetSmooth(const Vector3 &position) const
{
if(position.x < 0 || position.y < 0 || position.z < 0 || position.x >= _resolutionX || position.y >= _resolutionY || position.z >= _resolutionZ)
return 0;
return _voxels[static_cast<uint32>(position.x) * _resolutionY * _resolutionZ + static_cast<uint32>(position.y) * _resolutionZ + static_cast<uint32>(position.z)].smoothDensity;
}
void VoxelEntity::MakePlane(uint32 height)
{
for(uint32 x = 0; x < _resolutionX; x++)
{
for(uint32 y = 0; y < _resolutionY; y++)
{
for(uint32 z = 0; z < _resolutionZ; z++)
{
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z] = Point((y <= height)? 255:0);
}
}
}
}
void VoxelEntity::SetCubeLocal(Vector3 position, Vector3 size, uint32 density)
{
for(uint32 x = 0; x < _resolutionX; x++)
{
for(uint32 y = 0; y < _resolutionY; y++)
{
for(uint32 z = 0; z < _resolutionZ; z++)
{
if(abs(x - position.x) <= size.x && abs(y - position.y) <= size.y && abs(z - position.z) <= size.z)
{
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z] = Point(density);
}
}
}
}
}
void VoxelEntity::SetSphereLocal(Vector3 position, float radius, uint32 density)
{
for(uint32 x = 0; x < _resolutionX; x++)
{
for(uint32 y = 0; y < _resolutionY; y++)
{
for(uint32 z = 0; z < _resolutionZ; z++)
{
float dist = Vector3(x, y, z).GetDistance(position);
if(dist <= radius)
{
//float factor = (radius - dist) / radius;
//density = _surface * (1.0f - factor) + density * factor;
_voxels[x * _resolutionY * _resolutionZ + y * _resolutionZ + z] = Point(density);
}
}
}
}
}
void VoxelEntity::SetSphere(Vector3 position, float radius)
{
Vector3 offset(_resolutionX * 0.5f, _resolutionY * 0.5f, _resolutionZ * 0.5f);
position = GetWorldRotation().Conjugate().GetRotatedVector(position - GetWorldPosition()) / GetWorldScale();
position += offset;
SetSphereLocal(position, radius / GetWorldScale().GetMin(), 255);
}
void VoxelEntity::RemoveSphere(Vector3 position, float radius)
{
Vector3 offset(_resolutionX * 0.5f, _resolutionY * 0.5f, _resolutionZ * 0.5f);
position = GetWorldRotation().Conjugate().GetRotatedVector(position - GetWorldPosition()) / GetWorldScale();
position += offset;
SetSphereLocal(position, radius / GetWorldScale().GetMin(), 0);
}
void VoxelEntity::SetCube(Vector3 position, Vector3 size)
{
Vector3 offset(_resolutionX * 0.5f, _resolutionY * 0.5f, _resolutionZ * 0.5f);
position = GetWorldRotation().Conjugate().GetRotatedVector(position - GetWorldPosition()) / GetWorldScale();
position += offset;
SetCubeLocal(position, size / GetWorldScale(), 255);
}
void VoxelEntity::RemoveCube(Vector3 position, Vector3 size)
{
Vector3 offset(_resolutionX * 0.5f, _resolutionY * 0.5f, _resolutionZ * 0.5f);
position = GetWorldRotation().Conjugate().GetRotatedVector(position - GetWorldPosition()) / GetWorldScale();
position += offset;
SetCubeLocal(position, size / GetWorldScale(), 0);
}
Vector3 VoxelEntity::LerpSurface(const Vector3 &p1, const Vector3 &p2, uint8 d1, uint8 d2) const
{
if(_surface == d1)
return p1;
if(_surface == d2)
return p2;
if(d1 == d2)
return p1;
float factor = (_surface - d1) / static_cast<float>(d2 - d1);
Vector3 p;
p.x = p1.x + factor * (p2.x - p1.x);
p.y = p1.y + factor * (p2.y - p1.y);
p.z = p1.z + factor * (p2.z - p1.z);
return p;
}
uint32 VoxelEntity::GetID(const Vector3 &position) const
{
uint32 x = (position.x+1.2f);
uint32 y = (position.y+1.2f);
uint32 z = (position.z+1.2f);
return x*(_resolutionY+1.0f)*(_resolutionZ+1)+y*(_resolutionZ+1)+z;
}
void VoxelEntity::UpdateMesh()
{
const int edgeTable[256] = {
0x0 , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0};
const int triTable[256][16] = {
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
{3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
{4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
{9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
{10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
{5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
{8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
{2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
{11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
{5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
{11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
{11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
{9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
{6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
{6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
{8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
{7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
{3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
{9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
{8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
{0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
{6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
{10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
{10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
{0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
{3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
{9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
{8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
{3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
{10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
{10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
{7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
{1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
{11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
{8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
{0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
{7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
{7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
{10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
{0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
{7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
{9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
{6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
{4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
{10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
{8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
{1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
{10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
{10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
{9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
{7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
{3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
{7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
{3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
{6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
{9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
{1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
{4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
{7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
{6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
{0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
{6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
{0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
{11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
{6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
{5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
{9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
{1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
{10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
{0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
{5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
{11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
{9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
{7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
{2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
{9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
{1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
{10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
{2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
{0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
{0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
{9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
{5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
{5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
{9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
{1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
{3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
{4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
{9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
{11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
{2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
{9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
{3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
{1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
{4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
{0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
{1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}};
std::vector<Vector3> vertices;
std::unordered_map<std::pair<uint32, uint32>, uint32, __LookupHashMarchingCubes, __LookupCompareMarchingCubes> indexLookup;
std::vector<uint32> indices;
Vector3 halfResolution(_resolutionX * 0.5f, _resolutionY * 0.5f, _resolutionZ * 0.5f);
ApplyBlur(Vector3(0.0f), Vector3(0.0f), 2);
for(int32 x = 0; x <= _resolutionX; x++)
{
for(int32 y = 0; y <= _resolutionY; y++)
{
for(int32 z = 0; z <= _resolutionZ; z++)
{
Vector3 pos00 = RN::Vector3(x-1, y-1, z-1);
Vector3 pos01 = RN::Vector3(x, y-1, z-1);
Vector3 pos02 = RN::Vector3(x, y-1, z);
Vector3 pos03 = RN::Vector3(x-1, y-1, z);
Vector3 pos10 = RN::Vector3(x-1, y, z-1);
Vector3 pos11 = RN::Vector3(x, y, z-1);
Vector3 pos12 = RN::Vector3(x, y, z);
Vector3 pos13 = RN::Vector3(x-1, y, z);
uint8 v00 = GetSmooth(pos00);
uint8 v01 = GetSmooth(pos01);
uint8 v02 = GetSmooth(pos02);
uint8 v03 = GetSmooth(pos03);
uint8 v10 = GetSmooth(pos10);
uint8 v11 = GetSmooth(pos11);
uint8 v12 = GetSmooth(pos12);
uint8 v13 = GetSmooth(pos13);
int cubeindex = 0;
if(v00 > _surface) cubeindex |= 1;
if(v01 > _surface) cubeindex |= 2;
if(v02 > _surface) cubeindex |= 4;
if(v03 > _surface) cubeindex |= 8;
if(v10 > _surface) cubeindex |= 16;
if(v11 > _surface) cubeindex |= 32;
if(v12 > _surface) cubeindex |= 64;
if(v13 > _surface) cubeindex |= 128;
/* Cube is entirely in/out of the surface */
if(edgeTable[cubeindex] == 0)
continue;
Vector3 vertlist[12];
std::pair<uint32, uint32> vertLookup[12];
/* Find the vertices where the surface intersects the cube */
if(edgeTable[cubeindex] & 1)
{
vertlist[0] = LerpSurface(pos00, pos01, v00, v01);
vertLookup[0] = std::make_pair(GetID(pos00), GetID(pos01));
}
if(edgeTable[cubeindex] & 2)
{
vertlist[1] = LerpSurface(pos01, pos02, v01, v02);
vertLookup[1] = std::make_pair(GetID(pos01), GetID(pos02));
}
if(edgeTable[cubeindex] & 4)
{
vertlist[2] = LerpSurface(pos02, pos03, v02, v03);
vertLookup[2] = std::make_pair(GetID(pos02), GetID(pos03));
}
if(edgeTable[cubeindex] & 8)
{
vertlist[3] = LerpSurface(pos03, pos00, v03, v00);
vertLookup[3] = std::make_pair(GetID(pos03), GetID(pos00));
}
if(edgeTable[cubeindex] & 16)
{
vertlist[4] = LerpSurface(pos10, pos11, v10, v11);
vertLookup[4] = std::make_pair(GetID(pos10), GetID(pos11));
}
if(edgeTable[cubeindex] & 32)
{
vertlist[5] = LerpSurface(pos11, pos12, v11, v12);
vertLookup[5] = std::make_pair(GetID(pos11), GetID(pos12));
}
if(edgeTable[cubeindex] & 64)
{
vertlist[6] = LerpSurface(pos12, pos13, v12, v13);
vertLookup[6] = std::make_pair(GetID(pos12), GetID(pos13));
}
if(edgeTable[cubeindex] & 128)
{
vertlist[7] = LerpSurface(pos13, pos10, v13, v10);
vertLookup[7] = std::make_pair(GetID(pos13), GetID(pos10));
}
if(edgeTable[cubeindex] & 256)
{
vertlist[8] = LerpSurface(pos00, pos10, v00, v10);
vertLookup[8] = std::make_pair(GetID(pos00), GetID(pos10));
}
if(edgeTable[cubeindex] & 512)
{
vertlist[9] = LerpSurface(pos01, pos11, v01, v11);
vertLookup[9] = std::make_pair(GetID(pos01), GetID(pos11));
}
if(edgeTable[cubeindex] & 1024)
{
vertlist[10] = LerpSurface(pos02, pos12, v02, v12);
vertLookup[10] = std::make_pair(GetID(pos02), GetID(pos12));
}
if(edgeTable[cubeindex] & 2048)
{
vertlist[11] = LerpSurface(pos03, pos13, v03, v13);
vertLookup[11] = std::make_pair(GetID(pos03), GetID(pos13));
}
for(int i = 0; triTable[cubeindex][i] != -1; i++)
{
auto index0 = indexLookup.find(vertLookup[triTable[cubeindex][i]]);
if(index0 != indexLookup.end())
{
indices.push_back(index0->second);
}
else
{
indexLookup[vertLookup[triTable[cubeindex][i]]] = static_cast<uint32>(vertices.size());
indices.push_back(static_cast<uint32>(vertices.size()));
vertices.push_back(vertlist[triTable[cubeindex][i]] - halfResolution);
}
}
}
}
}
SafeRelease(_mesh);
_mesh = new Mesh({ Mesh::VertexAttribute(Mesh::VertexAttribute::Feature::Vertices, PrimitiveType::Vector3),
Mesh::VertexAttribute(Mesh::VertexAttribute::Feature::Normals, PrimitiveType::Vector3),
Mesh::VertexAttribute(Mesh::VertexAttribute::Feature::Indices, PrimitiveType::Uint32) }, vertices.size(), indices.size());
_mesh->BeginChanges();
Mesh::Chunk chunk = _mesh->GetChunk();
Mesh::ElementIterator<Vector3> vertexIterator = chunk.GetIterator<Vector3>(Mesh::VertexAttribute::Feature::Vertices);
Mesh::ElementIterator<Vector3> normalsIterator = chunk.GetIterator<Vector3>(Mesh::VertexAttribute::Feature::Normals);
Mesh::ElementIterator<uint32> indexIterator = chunk.GetIterator<uint32>(Mesh::VertexAttribute::Feature::Indices);
for(int i = 0; i < vertices.size(); i++)
{
*vertexIterator++ = vertices[i];
*normalsIterator++ = Vector3(0.0f);
}
for(int i = 0; i < indices.size(); i += 3)
{
Vector3 normal = (vertices[indices[i]]-vertices[indices[i+2]]).GetCrossProduct(vertices[indices[i+1]]-vertices[indices[i+2]]).GetNormalized();
*normalsIterator.Seek(indices[i]) += normal;
*normalsIterator.Seek(indices[i+1]) += normal;
*normalsIterator.Seek(indices[i+2]) += normal;
*indexIterator++ = indices[i];
*indexIterator++ = indices[i+1];
*indexIterator++ = indices[i+2];
}
_mesh->changedVertices = true;
_mesh->changedIndices = true;
_mesh->EndChanges();
}
bool VoxelEntity::CanRender(Renderer *renderer, Camera *camera) const
{
//TODO: Add occlusion culling or something
return true;
}
void VoxelEntity::Render(Renderer *renderer, Camera *camera) const
{
SceneNode::Render(renderer, camera);
if(!_material)
return;
_drawable->Update(_mesh, _material, nullptr, this);
renderer->SubmitDrawable(_drawable);
}
}
| 42.362416 | 177 | 0.462611 | uberpixel |
a6e47799fe0a0eb1c1d78764fa8406d96b26767d | 2,843 | cpp | C++ | src/ariel/rendersys.cpp | lymastee/gslib | 1b165b7a812526c4b2a3179588df9a7c2ff602a6 | [
"MIT"
] | 9 | 2016-10-18T09:40:09.000Z | 2022-02-11T09:44:51.000Z | src/ariel/rendersys.cpp | lymastee/gslib | 1b165b7a812526c4b2a3179588df9a7c2ff602a6 | [
"MIT"
] | null | null | null | src/ariel/rendersys.cpp | lymastee/gslib | 1b165b7a812526c4b2a3179588df9a7c2ff602a6 | [
"MIT"
] | 1 | 2016-10-19T15:20:58.000Z | 2016-10-19T15:20:58.000Z | /*
* Copyright (c) 2016-2021 lymastee, All rights reserved.
* Contact: lymastee@hotmail.com
*
* This file is part of the gslib project.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <ariel/rendersys.h>
__ariel_begin__
rendersys::rsys_map rendersys::_dev_indexing;
rendersys::rendersys():
_bkcr {0.f, 0.f, 0.f, 1.f}
{
}
bool rendersys::is_vsync_enabled(const configs& cfg)
{
auto f = cfg.find(_t("vsync"));
if(f == cfg.end())
return false;
return f->second == _t("true") || f->second == _t("1");
}
bool rendersys::is_full_screen(const configs& cfg)
{
auto f = cfg.find(_t("fullscreen"));
if(f == cfg.end())
return false;
return f->second == _t("true") || f->second == _t("1");
}
bool rendersys::is_MSAA_enabled(const configs& cfg)
{
auto f = cfg.find(_t("msaa"));
if(f == cfg.end())
return false;
return f->second == _t("true") || f->second == _t("1");
}
uint rendersys::get_MSAA_sampler_count(const configs& cfg)
{
auto f = cfg.find(_t("msaa_sampler_count"));
if(f == cfg.end())
return 0;
return (uint)f->second.to_int();
}
void rendersys::set_background_color(const color& cr)
{
_bkcr[0] = (float)cr.red / 255.f;
_bkcr[1] = (float)cr.green / 255.f;
_bkcr[2] = (float)cr.blue / 255.f;
_bkcr[3] = (float)cr.alpha / 255.f;
}
void rendersys::register_dev_index_service(void* dev, rendersys* rsys)
{
_dev_indexing.emplace(dev, rsys);
}
void rendersys::unregister_dev_index_service(void* dev)
{
_dev_indexing.erase(dev);
}
rendersys* rendersys::find_by_dev(void* dev)
{
auto f = _dev_indexing.find(dev);
return f == _dev_indexing.end() ? nullptr : f->second;
}
__ariel_end__
| 29.926316 | 82 | 0.663384 | lymastee |
a6e59c6f62d53c16c9bfce330de63e57f40b9af7 | 2,263 | cpp | C++ | fill the pixels/fill_the_pixels.cpp | papachristoumarios/IEEEXtreme11.0 | 4c3b5aaa71641a6d0b3e9823c4738050f2553b27 | [
"MIT"
] | 13 | 2018-10-11T14:13:56.000Z | 2022-02-17T18:30:17.000Z | fill the pixels/fill_the_pixels.cpp | papachristoumarios/IEEEXtreme11.0-PComplete | 4c3b5aaa71641a6d0b3e9823c4738050f2553b27 | [
"MIT"
] | null | null | null | fill the pixels/fill_the_pixels.cpp | papachristoumarios/IEEEXtreme11.0-PComplete | 4c3b5aaa71641a6d0b3e9823c4738050f2553b27 | [
"MIT"
] | 7 | 2018-10-24T08:36:59.000Z | 2021-07-19T18:16:53.000Z | #include <iostream>
#include <vector>
#include <queue>
#include <set>
#include <map>
using namespace std;
#define MAXW 1000
#define pii pair < int , int >
#define mp make_pair
char A [ MAXW + 1] [MAXW + 1];
bool visited [ MAXW + 1] [ MAXW + 1];
vector<pii> get_neighbours(int N, int M, int i, int j, char symbol) {
if (symbol == '+') {
vector<pii> neigh;
neigh.push_back(mp(i-1, j));
neigh.push_back(mp(i, j-1));
neigh.push_back(mp(i+1, j));
neigh.push_back(mp(i, j + 1));
vector<pii> ret;
for (pii n : ret) {
int k = n.first;
int l = n.second;
if (k >= 0 && k < N && l >= 0 && l < M) ret.push_back(n);
}
return ret;
}
else if (symbol == 'x') {
vector<pii> neigh;
neigh.push_back(mp(i-1, j-1));
neigh.push_back(mp(i+1, j-1));
neigh.push_back(mp(i+1, j+1));
neigh.push_back(mp(i-1, j+1));
vector<pii> ret;
for (pii n : ret) {
int k = n.first;
int l = n.second;
if (k >= 0 && k < N && l >= 0 && l < M) ret.push_back(n);
}
return ret;
}
else {
vector<pii> n1;
vector<pii> n2;
n1 = get_neighbours(N, M, i, j, '+');
n2 = get_neighbours(N, M, i, j, 'x');
for (pii n : n2) n1.push_back(n);
return n1;
}
}
void solve() {
int M, N;
cin >> M >> N;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
cin >> A[i][j];
visited[i][j] = false;
}
vector<pii> nn;
nn = get_neighbours(N, M, N / 2, M / 2, '+');
for (pii n : nn) {
cout << n.first << " " << n.second << endl;
}
char symbols[3] = { '+', 'x', '-' };
int total;
for (char symbol : symbols) {
total = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (visited[i][j] || A[i][j] == '0') {
continue;
}
queue<pii> q;
q.push(mp(i,j));
while (!q.empty()) {
pii current = q.front();
q.pop();
int x = current.first;
int y = current.second;
vector<pii> neigh;
neigh = get_neighbours(N, M, x, y, symbol);
for (pii n : neigh) {
int k = n.first;
int l = n.second;
if (!visited[k][l]) {
q.push(n); visited[k][l] = true;
}
}
}
total++;
}
}
printf("%d ", total);
}
}
int main(void) {
int T;
cin >> T;
while (T--) solve();
}
| 18.398374 | 69 | 0.492267 | papachristoumarios |
a6e5c2bec1f49071ef3a8df5348fc465336955a4 | 981 | cpp | C++ | src/DynamicProgramming/RegionalDP/MinimumMergeCost.cpp | S1xe/Way-to-Algorithm | e666edfb000b3eaef8cc1413f71b035ec4141718 | [
"MIT"
] | 101 | 2015-11-19T02:40:01.000Z | 2017-12-01T13:43:06.000Z | src/DynamicProgramming/RegionalDP/MinimumMergeCost.cpp | S1xe/Way-to-Algorithm | e666edfb000b3eaef8cc1413f71b035ec4141718 | [
"MIT"
] | 3 | 2019-05-31T14:27:56.000Z | 2021-07-28T04:24:55.000Z | src/DynamicProgramming/RegionalDP/MinimumMergeCost.cpp | S1xe/Way-to-Algorithm | e666edfb000b3eaef8cc1413f71b035ec4141718 | [
"MIT"
] | 72 | 2016-01-28T15:20:01.000Z | 2017-12-01T13:43:07.000Z | #include "MinimumMergeCost.h"
#include "../Util.h"
#include <algorithm>
#include <climits>
#include <cstdarg>
#include <iostream>
#include <string>
// 防止int溢出
static int Add(int a = 0, int b = 0, int c = 0) {
if (a == INF || b == INF || c == INF)
return INF;
return a + b + c;
}
int MinimumMergeCost(int *s, int n) {
int **f = Array2DNew(n + 1, n + 1);
int **sum = Array2DNew(n + 1, n + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
f[i][j] = (i == j) ? 0 : INF;
sum[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = i; k <= j; k++)
sum[i][j] += s[k];
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
for (int k = i; k < j; k++) {
f[i][j] = std::min(
f[i][j], Add(Add(f[i][k], f[k + 1][j]), sum[i][k], sum[k + 1][j]));
}
int result = f[1][n];
Array2DFree(f, n + 1);
Array2DFree(sum, n + 1);
return result;
}
| 21.8 | 79 | 0.448522 | S1xe |
a6ea3199d6a5328394c15e2a0f1196d56c1424d4 | 33,717 | cpp | C++ | net/src/net_socket.cpp | ARMmbed/mbed-os-posix-socket | 8797ebb01d5b3f96b59616eba65ee9b0d67e17c8 | [
"Apache-2.0"
] | null | null | null | net/src/net_socket.cpp | ARMmbed/mbed-os-posix-socket | 8797ebb01d5b3f96b59616eba65ee9b0d67e17c8 | [
"Apache-2.0"
] | null | null | null | net/src/net_socket.cpp | ARMmbed/mbed-os-posix-socket | 8797ebb01d5b3f96b59616eba65ee9b0d67e17c8 | [
"Apache-2.0"
] | null | null | null | #include "BSDSocket.h"
#include "EventFileHandle.h"
#include "FdControlBlock.h"
#include "OpenFileHandleAsFileDescriptor.h"
#include <net_socket.h>
#include <rtos/EventFlags.h>
#include <netsocket/MsgHeader.h>
#include <net_if.h>
#include <ifaddrs.h>
#include "net_common.h"
#include "mbed-trace/mbed_trace.h"
using namespace mbed;
using namespace rtos;
#define TRACE_GROUP "NETS"
#define NO_FREE_SOCKET_SLOT (-1)
static BSDSocket sockets[MBED_NET_SOCKET_MAX_NUMBER];
static BSDSocket * getBSDSocket(int fd)
{
BSDSocket * socket = static_cast<BSDSocket *>(mbed_file_handle(fd));
if (socket == nullptr)
{
return nullptr;
}
return socket;
}
static Socket * getSocket(int fd)
{
BSDSocket * socket = static_cast<BSDSocket *>(mbed_file_handle(fd));
if (socket == nullptr)
{
return nullptr;
}
return socket->getNetSocket();
}
struct mbed_socket_option_t
{
int level;
int optname;
};
static mbed_socket_option_t convert_socket_option(int level, int optname)
{
if (level == SOL_SOCKET) {
switch (optname)
{
case SO_REUSEADDR:
return { NSAPI_SOCKET, NSAPI_REUSEADDR };
case SO_KEEPALIVE:
return { NSAPI_SOCKET, NSAPI_KEEPALIVE };
case SO_BROADCAST:
return { NSAPI_SOCKET, NSAPI_BROADCAST };
case SO_BINDTODEVICE:
return { NSAPI_SOCKET, NSAPI_BIND_TO_DEVICE };
default:
tr_warning("Passing unknown socket option %d to socket", optname);
return { level, optname };
}
} else if (level == IPPROTO_IP) {
switch (optname)
{
case IP_ADD_MEMBERSHIP:
return { NSAPI_SOCKET, NSAPI_ADD_MEMBERSHIP };
case IP_DROP_MEMBERSHIP:
return { NSAPI_SOCKET, NSAPI_DROP_MEMBERSHIP };
case IP_PKTINFO:
return { NSAPI_SOCKET, NSAPI_PKTINFO };
default:
tr_warning("Passing unknown IP4 option %d to socket", optname);
return { level, optname };
}
} else if (level == IPPROTO_IPV6) {
switch (optname)
{
case IPV6_ADD_MEMBERSHIP:
return { NSAPI_SOCKET, NSAPI_ADD_MEMBERSHIP };
case IPV6_DROP_MEMBERSHIP:
return { NSAPI_SOCKET, NSAPI_DROP_MEMBERSHIP };
case IPV6_PKTINFO:
return { NSAPI_SOCKET, NSAPI_PKTINFO };
default:
tr_warning("Passing unknown IP6 option %d to socket", optname);
return { level, optname };
}
} else {
tr_warning("Passing unknown option %d to socket", optname);
return { level, optname };
}
}
int getFreeSocketSlotIndex()
{
int index = NO_FREE_SOCKET_SLOT;
for (int i = 0; i < MBED_NET_SOCKET_MAX_NUMBER; i++)
{
if (!sockets[i].isSocketOpen())
{
index = i;
break;
}
}
return index;
}
int mbed_socket(int family, int type, int proto)
{
tr_info("Create socket family %d type %d proto %d", family, type, proto);
int index = getFreeSocketSlotIndex();
if (index == NO_FREE_SOCKET_SLOT)
{
tr_err("No free socket slot");
set_errno(ENOBUFS);
return -1;
}
BSDSocket * socket = &sockets[index];
return socket->open(family, type);
}
int mbed_socketpair(int family, int type, int proto, int sv[2])
{
set_errno(EAFNOSUPPORT);
return -1;
}
int mbed_shutdown(int fd, int how)
{
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (how != SHUT_RD && how != SHUT_WR && how != SHUT_RDWR)
{
set_errno(EINVAL);
return -1;
}
tr_info("Shutdown fd %d how %d", fd, how);
switch (how)
{
case SHUT_RD:
socket->enable_input(false);
break;
case SHUT_WR:
socket->enable_output(false);
break;
case SHUT_RDWR:
socket->enable_input(false);
socket->enable_output(false);
break;
}
return 0;
}
int mbed_bind(int fd, const struct sockaddr * addr, socklen_t addrlen)
{
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (addr == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (socket->socketName)
{
set_errno(EINVAL);
return -1;
}
SocketAddress sockAddr;
if (convert_bsd_addr_to_mbed(&sockAddr, (struct sockaddr *) addr))
{
set_errno(EINVAL);
return -1;
}
tr_info("Bind fd %d address %s port %d", fd, sockAddr.get_ip_address(), sockAddr.get_port());
auto ret = socket->getNetSocket()->bind(sockAddr);
if ((ret != NSAPI_ERROR_OK) && (ret != NSAPI_ERROR_UNSUPPORTED))
{
tr_err("Bind failed [%d]", ret);
set_errno(EIO);
return -1;
}
socket->socketName = sockAddr;
return 0;
}
int mbed_connect(int fd, const struct sockaddr * addr, socklen_t addrlen)
{
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (addr == nullptr)
{
set_errno(EINVAL);
return -1;
}
SocketAddress sockAddr;
if (convert_bsd_addr_to_mbed(&sockAddr, (struct sockaddr *) addr))
{
set_errno(EINVAL);
return -1;
}
tr_info("Connect fd %d address %s", fd, sockAddr.get_ip_address());
auto ret = socket->connect(sockAddr);
if ((ret != NSAPI_ERROR_OK) && (ret != NSAPI_ERROR_UNSUPPORTED))
{
tr_err("Connect failed [%d]", ret);
switch (ret)
{
case NSAPI_ERROR_IN_PROGRESS:
set_errno(EALREADY);
break;
case NSAPI_ERROR_NO_SOCKET:
set_errno(EBADF);
break;
case NSAPI_ERROR_IS_CONNECTED:
set_errno(EISCONN);
break;
default:
set_errno(EIO);
}
return -1;
}
if (!socket->is_blocking())
{
tr_debug("Connect not blocking\n");
set_errno(EINPROGRESS);
return -1;
}
return 0;
}
int mbed_listen(int fd, int backlog)
{
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (backlog < 0)
{
set_errno(EINVAL);
return -1;
}
if (socket->getSocketType() != BSDSocket::MBED_TCP_SOCKET)
{
set_errno(EOPNOTSUPP);
return -1;
}
tr_info("Listen fd %d backlog %d", fd, backlog);
auto ret = socket->listen(backlog);
if ((ret != NSAPI_ERROR_OK) && (ret != NSAPI_ERROR_UNSUPPORTED))
{
tr_err("Listen failed [%d]", ret);
set_errno(EIO);
return -1;
}
return 0;
}
int mbed_accept(int fd, struct sockaddr * addr, socklen_t * addrlen)
{
nsapi_error_t error;
Socket * newSocket = nullptr;
int index;
SocketAddress sockAddr;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (addr == nullptr || addrlen == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (socket->getSocketType() != BSDSocket::MBED_TCP_SOCKET)
{
set_errno(EOPNOTSUPP);
return -1;
}
tr_info("Connection accept for fd %d socket", fd);
newSocket = socket->accept(&error);
if (error == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Accept would block", fd);
set_errno(EWOULDBLOCK);
return -1;
}
if ((error != NSAPI_ERROR_OK) && (error != NSAPI_ERROR_UNSUPPORTED))
{
tr_err("Accept failed [%d]", error);
set_errno(ENOBUFS);
return -1;
}
error = newSocket->getpeername(&sockAddr);
if (error != NSAPI_ERROR_OK)
{
tr_err("Get peer name failed [%d]", error);
delete newSocket;
switch (error)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_NO_CONNECTION:
set_errno(ECONNABORTED);
break;
default:
set_errno(ENOBUFS);
}
return -1;
}
if (convert_mbed_addr_to_bsd(addr, &sockAddr))
{
delete newSocket;
set_errno(EINVAL);
return -1;
}
index = getFreeSocketSlotIndex();
if (index == NO_FREE_SOCKET_SLOT)
{
tr_err("No free socket slot");
delete newSocket;
set_errno(ENOBUFS);
return -1;
}
return sockets[index].open(addr->sa_family, BSDSocket::MBED_TCP_SOCKET, (InternetSocket *) newSocket);
}
ssize_t mbed_send(int fd, const void * buf, size_t len, int flags)
{
ssize_t ret;
bool blockingState;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (buf == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_output_enable())
{
return 0;
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
tr_info("Socket fd %d send %d bytes", fd, len);
ret = socket->send(buf, len);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Send would block", fd);
} else {
tr_err("Send failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
case NSAPI_ERROR_NO_ADDRESS:
set_errno(ENOTCONN);
break;
default:
set_errno(ENOBUFS);
}
ret = -1;
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
return ret;
}
ssize_t mbed_sendto(int fd, const void * buf, size_t len, int flags, const struct sockaddr * dest_addr, socklen_t addrlen)
{
ssize_t ret;
bool blockingState;
SocketAddress sockAddr;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (buf == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_output_enable())
{
return 0;
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
if (dest_addr != nullptr)
{
if (convert_bsd_addr_to_mbed(&sockAddr, (struct sockaddr *) dest_addr) < 0)
{
set_errno(EINVAL);
return -1;
}
}
tr_info("Socket fd %d send %d bytes to %s", fd, len, sockAddr.get_ip_address());
ret = socket->sendto(sockAddr, buf, len);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Send to would block", fd);
} else {
tr_err("Send to failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
default:
set_errno(ENOBUFS);
}
ret = -1;
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
return ret;
}
ssize_t mbed_sendmsg(int fd, const struct msghdr * message, int flags)
{
ssize_t ret;
bool blockingState;
SocketAddress sockAddr;
nsapi_pktinfo pkt_info;
nsapi_msghdr_t* control = nullptr;
nsapi_size_t control_size = 0;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (message == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_output_enable())
{
return 0;
}
if (message->msg_iovlen != 1) {
// FIXME: concatenate buffers of the message
set_errno(ENOTSUP);
return -1;
}
// Parse header and retrieve associated packet info
for (cmsghdr * controlHdr = CMSG_FIRSTHDR(message); controlHdr != nullptr; controlHdr = CMSG_NXTHDR(message, controlHdr))
{
// Prepare the packet info header
pkt_info.hdr.len = sizeof(pkt_info);
pkt_info.hdr.level = NSAPI_SOCKET;
pkt_info.hdr.type = NSAPI_PKTINFO;
if (controlHdr->cmsg_level == IPPROTO_IP && controlHdr->cmsg_type == IP_PKTINFO)
{
struct in_pktinfo * inPktInfo = reinterpret_cast<struct in_pktinfo *> CMSG_DATA(controlHdr);
pkt_info.ipi_ifindex = inPktInfo->ipi_ifindex;
pkt_info.ipi_addr = SocketAddress(inPktInfo->ipi_spec_dst.s4_addr16, NSAPI_IPv4).get_addr();
control = reinterpret_cast<decltype(control)>(&pkt_info);
control_size = sizeof(pkt_info);
tr_info("Send packet IPv4: src: %s, interface: %d", tr_array(pkt_info.ipi_addr.bytes, NSAPI_IPv4_BYTES), pkt_info.ipi_ifindex);
break;
} else if (controlHdr->cmsg_level == IPPROTO_IPV6 && controlHdr->cmsg_type == IPV6_PKTINFO)
{
struct in6_pktinfo * in6PktInfo = reinterpret_cast<struct in6_pktinfo *> CMSG_DATA(controlHdr);
pkt_info.ipi_ifindex = in6PktInfo->ipi6_ifindex;
pkt_info.ipi_addr = SocketAddress(in6PktInfo->ipi6_addr.s6_addr, NSAPI_IPv6).get_addr();
control = reinterpret_cast<decltype(control)>(&pkt_info);
control_size = sizeof(pkt_info);
tr_info("Send packet IPv6: src: %s, interface: %d", tr_ipv6(pkt_info.ipi_addr.bytes), pkt_info.ipi_ifindex);
break;
}
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
if (convert_bsd_addr_to_mbed(&sockAddr, (struct sockaddr *) message->msg_name) < 0)
{
set_errno(EINVAL);
return -1;
}
tr_info("Socket fd %d send message to %s", fd, sockAddr.get_ip_address());
ret = socket->sendmsg(sockAddr, (void *) message->msg_iov[0].iov_base, message->msg_iov[0].iov_len, control, control_size);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Send msg would block", fd);
} else {
tr_err("Send msg failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
default:
set_errno(ENOBUFS);
}
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
return ret;
}
ssize_t mbed_recv(int fd, void * buf, size_t max_len, int flags)
{
ssize_t ret;
bool blockingState;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (buf == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_input_enable())
{
return 0;
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
ret = socket->recv(buf, max_len);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Receive would block", fd);
} else {
tr_err("Receive failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
default:
set_errno(ENOBUFS);
}
ret = -1;
}
else
{
SocketAddress peerAddr;
socket->getNetSocket()->getpeername(&peerAddr);
tr_info("Socket fd %d received %d bytes from %s", fd, ret, peerAddr.get_ip_address());
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
return ret;
}
ssize_t mbed_recvfrom(int fd, void * buf, size_t max_len, int flags, struct sockaddr * src_addr, socklen_t * addrlen)
{
ssize_t ret;
bool blockingState;
SocketAddress sockAddr;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (buf == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_input_enable())
{
return 0;
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
ret = socket->recvfrom(&sockAddr, buf, max_len);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Receive would block", fd);
} else {
tr_err("Receive failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
default:
set_errno(ENOBUFS);
}
ret = -1;
}
else
{
tr_info("Socket fd %d recevied %d bytes from %s", fd, ret, sockAddr.get_ip_address());
if (src_addr != nullptr)
{
if (convert_mbed_addr_to_bsd(src_addr, &sockAddr))
{
set_errno(EINVAL);
ret = -1;
}
}
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
return ret;
}
ssize_t mbed_recvmsg(int fd, struct msghdr * message, int flags)
{
bool blockingState;
SocketAddress sockAddr;
nsapi_pktinfo_t pkt_info;
nsapi_msghdr_t* control = nullptr;
nsapi_size_t control_size = 0;
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (message == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (!socket->is_input_enable())
{
return 0;
}
if (message->msg_iovlen != 1) {
// FIXME: concatenate buffers of the message
set_errno(ENOTSUP);
return -1;
}
if (message->msg_control && message->msg_controllen >= std::max(sizeof(in_pktinfo), sizeof(in6_pktinfo))) {
control = reinterpret_cast<decltype(control)>(&pkt_info);
control_size = sizeof(pkt_info);
memset(control, 0, control_size);
memset(message->msg_control, 0, message->msg_controllen);
}
if (flags & MSG_DONTWAIT)
{
blockingState = socket->is_blocking();
socket->set_blocking(false);
}
auto ret = socket->recvmsg(&sockAddr, (void *) message->msg_iov[0].iov_base, message->msg_iov[0].iov_len, control, control_size);
if (ret < 0)
{
if (ret == NSAPI_ERROR_WOULD_BLOCK) {
tr_debug("Socket fd %d: Receive msg would block", fd);
} else {
tr_err("Receive mag failed [%d]", ret);
}
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_WOULD_BLOCK:
set_errno(EWOULDBLOCK);
break;
default:
set_errno(ENOBUFS);
}
}
tr_info("Socket fd %d received %d bytes message from %s", fd, ret, sockAddr.get_ip_address());
if (ret != -1)
{
if (message->msg_name != nullptr)
{
if (convert_mbed_addr_to_bsd((sockaddr *) message->msg_name, &sockAddr))
{
set_errno(EINVAL);
ret = -1;
}
}
}
if (flags & MSG_DONTWAIT)
{
socket->set_blocking(blockingState);
}
nsapi_pktinfo_t *pkt_info_ptr = nullptr;
if (control) {
MsgHeaderIterator it(control, control_size);
while (it.has_next()) {
auto *hdr = it.next();
if (hdr->level == NSAPI_SOCKET && hdr->type == NSAPI_PKTINFO) {
pkt_info_ptr = reinterpret_cast<nsapi_pktinfo_t*>(hdr);
break;
}
}
}
// retrieve packet info and fill it in msg_control
if (control && ret >= 0 && pkt_info_ptr) {
pkt_info = *pkt_info_ptr;
struct cmsghdr * hdr = CMSG_FIRSTHDR(message);
if (pkt_info.ipi_addr.version == NSAPI_IPv4) {
hdr->cmsg_level = IPPROTO_IP;
hdr->cmsg_type = IP_PKTINFO;
hdr->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));
struct in_pktinfo * pktInfo = reinterpret_cast<struct in_pktinfo *> CMSG_DATA(hdr);
pktInfo->ipi_ifindex = static_cast<decltype(pktInfo->ipi_ifindex)>(pkt_info.ipi_ifindex);
memcpy(pktInfo->ipi_spec_dst.s4_addr, pkt_info.ipi_addr.bytes, sizeof(pktInfo->ipi_spec_dst.s4_addr));
message->msg_controllen = CMSG_SPACE(sizeof(in_pktinfo));
tr_debug("Received packet: src: %s, interface: %d", tr_array(pkt_info.ipi_addr.bytes, NSAPI_IPv4_BYTES), pkt_info.ipi_ifindex);
} else if (pkt_info.ipi_addr.version == NSAPI_IPv6) {
hdr->cmsg_level = IPPROTO_IPV6;
hdr->cmsg_type = IPV6_PKTINFO;
hdr->cmsg_len = CMSG_LEN(sizeof(in6_pktinfo));
struct in6_pktinfo * pktInfo = reinterpret_cast<struct in6_pktinfo *> CMSG_DATA(hdr);
pktInfo->ipi6_ifindex = static_cast<decltype(pktInfo->ipi6_ifindex)>(pkt_info.ipi_ifindex);
memcpy(pktInfo->ipi6_addr.s6_addr, pkt_info.ipi_addr.bytes, sizeof(pktInfo->ipi6_addr.s6_addr));
message->msg_controllen = CMSG_SPACE(sizeof(in6_pktinfo));
tr_debug("Received packet: src: %s, interface: %d", tr_ipv6(pkt_info.ipi_addr.bytes), pkt_info.ipi_ifindex);
}
}
return ret;
}
int mbed_getsockopt(int fd, int level, int optname, void * optval, socklen_t * optlen)
{
auto * socket = getSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
// Use NSAPI options instead of POSIX one
auto opt = convert_socket_option(level, optname);
auto ret = socket->getsockopt(opt.level, opt.optname, optval, optlen);
if (ret < 0)
{
tr_err("Get socket option %s [%d]", ret == NSAPI_ERROR_UNSUPPORTED ? "unsupported" : "failed", ret);
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_UNSUPPORTED:
if ((optname == SO_ERROR) || (optval != nullptr))
{
*(int *) optval = 0;
return 0;
}
set_errno(ENOPROTOOPT);
break;
default:
set_errno(ENOBUFS);
}
return -1;
}
tr_info("Get socket fd %d option level %d optname %d", fd, level, optname);
return 0;
}
int mbed_setsockopt(int fd, int level, int optname, const void * optval, socklen_t optlen)
{
auto * socket = getSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
// Convert the option to NSAPI option alias
auto opt = convert_socket_option(level, optname);
int ret = -1;
// Handle the conversion of arguments for options that requires it
if (level == IPPROTO_IP && ((optname == IP_ADD_MEMBERSHIP) || (optname == IP_DROP_MEMBERSHIP))) {
if (optval == nullptr || optlen != sizeof(ip_mreq)) {
tr_err("Set socket option invalid ip_mreq: level = %d, optname=%d, val=%p, len=%d => [%d]",
level, optname, optval, optlen, ret);
set_errno(EINVAL);
return -1;
}
const ip_mreq* bsd_opt = reinterpret_cast<const ip_mreq*>(optval);
nsapi_ip_mreq_t opt_val = {};
opt_val.imr_multiaddr.version = NSAPI_IPv4;
memcpy(opt_val.imr_multiaddr.bytes, bsd_opt->imr_multiaddr.s4_addr, sizeof(bsd_opt->imr_multiaddr.s4_addr));
opt_val.imr_interface.version = NSAPI_IPv4;
memcpy(opt_val.imr_interface.bytes, bsd_opt->imr_interface.s4_addr, sizeof(bsd_opt->imr_interface.s4_addr));
ret = socket->setsockopt(opt.level, opt.optname, &opt_val, sizeof(opt_val));
} else if (level == IPPROTO_IPV6 && ((optname == IPV6_ADD_MEMBERSHIP) || (optname == IPV6_DROP_MEMBERSHIP))) {
if (optval == nullptr || optlen != sizeof(ipv6_mreq)) {
tr_err("Set socket option invalid ipv6_mreq: level = %d, optname=%d, val=%p, len=%d expected len=%d => [%d]",
level, optname, optval, optlen, sizeof(ipv6_mreq), ret);
set_errno(EINVAL);
return -1;
}
const ipv6_mreq* bsd_opt = reinterpret_cast<const ipv6_mreq*>(optval);
// Initialize the socket option and copy the multicast address in it
nsapi_ip_mreq_t opt_val = {};
opt_val.imr_multiaddr.version = NSAPI_IPv6;
memcpy(opt_val.imr_multiaddr.bytes, bsd_opt->ipv6mr_multiaddr.s6_addr, sizeof(bsd_opt->ipv6mr_multiaddr.s6_addr));
// The POSIX and Mbed socket differ from here: The POSIX socket API contains
// the interface ID while the Mbed API contains the interface IP address.
// The IP address of the interface is retrieved with the if_ functions.
// Retrieve the interface name
char ifname[IF_NAMESIZE];
if (if_indextoname(bsd_opt->ipv6mr_interface, ifname) == nullptr) {
tr_error("Cannot retrieve network interface %d", bsd_opt->ipv6mr_interface);
set_errno(EINVAL);
return -1;
}
// Retrieve the interface address
struct ifaddrs* ifap;
if (mbed_getifaddrs(&ifap)) {
tr_error("Cannot retrieve list of network interfaces");
set_errno(EINVAL);
return -1;
}
while (ifap) {
if (ifap->ifa_name && strcmp(ifap->ifa_name, ifname) == 0 &&
ifap->ifa_addr && ifap->ifa_addr->sa_family == AF_INET6
) {
opt_val.imr_interface.version = NSAPI_IPv6;
struct sockaddr_in6* addr = reinterpret_cast<struct sockaddr_in6*>(ifap->ifa_addr);
memcpy(opt_val.imr_interface.bytes, addr->sin6_addr.s6_addr, sizeof(addr->sin6_addr.s6_addr));
tr_debug("Sending interface address %s as part of socket option",
SocketAddress((void*)opt_val.imr_interface.bytes, NSAPI_IPv6).get_ip_address()
);
break;
}
ifap = ifap->ifa_next;
}
mbed_freeifaddrs(ifap);
// Return of the ip of the interface hasn't been set
if (opt_val.imr_interface.version != NSAPI_IPv6) {
tr_error("Cannot retrieve IPv6 address for interface %d", bsd_opt->ipv6mr_interface);
set_errno(EINVAL);
return -1;
}
ret = socket->setsockopt(opt.level, opt.optname, &opt_val, sizeof(opt_val));
}else {
ret = socket->setsockopt(opt.level, opt.optname, optval, optlen);
}
if (ret < 0)
{
tr_err("Set socket option %s: level = %d, optname=%d, val=%p, len=%d => [%d]",
ret == NSAPI_ERROR_UNSUPPORTED ? "unsupported" : "failed", level, optname, optval, optlen, ret);
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_UNSUPPORTED:
set_errno(ENOPROTOOPT);
break;
default:
set_errno(ENOBUFS);
}
return -1;
}
tr_info("Set socket fd %d option level %d optname %d", fd, level, optname);
return 0;
}
int mbed_getsockname(int fd, struct sockaddr * addr, socklen_t * addrlen)
{
auto * socket = getBSDSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (addr == nullptr || addrlen == nullptr)
{
set_errno(EINVAL);
return -1;
}
if (socket->socketName)
{
set_errno(EINVAL);
return -1;
}
tr_info("Get socket fd %d name", fd);
if (socket->socketName.get_ip_version() == NSAPI_IPv4)
{
if (*addrlen < sizeof(sockaddr_in))
{
*addrlen = sizeof(sockaddr_in);
set_errno(ENOBUFS);
return -1;
}
}
else if (socket->socketName.get_ip_version() == NSAPI_IPv6)
{
if (*addrlen < sizeof(sockaddr_in6))
{
*addrlen = sizeof(sockaddr_in6);
set_errno(ENOBUFS);
return -1;
}
}
if (convert_mbed_addr_to_bsd(addr, &socket->socketName) < 0)
{
set_errno(ENOBUFS);
return -1;
}
return 0;
}
int mbed_getpeername(int fd, struct sockaddr * addr, socklen_t * addrlen)
{
SocketAddress sockAddr;
auto * socket = getSocket(fd);
if (socket == nullptr)
{
set_errno(EBADF);
return -1;
}
if (addr == nullptr || addrlen == nullptr)
{
set_errno(EINVAL);
return -1;
}
auto ret = socket->getpeername(&sockAddr);
if (ret < 0)
{
tr_err("Get peer name failed [%d]", ret);
switch (ret)
{
case NSAPI_ERROR_NO_SOCKET:
set_errno(ENOTSOCK);
break;
case NSAPI_ERROR_NO_CONNECTION:
set_errno(ENOTCONN);
break;
default:
set_errno(ENOBUFS);
}
return -1;
}
tr_info("Get socket fd %d peer name", fd);
convert_mbed_addr_to_bsd(addr, &sockAddr);
return 0;
}
static int get_max_select_fd(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds)
{
int max;
max = nfds;
for (int fd = max; fd < FD_SETSIZE; ++fd)
{
if (FD_ISSET(fd, readfds) || FD_ISSET(fd, writefds) || FD_ISSET(fd, exceptfds))
{
max++;
}
}
return max;
}
int mbed_select(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval * timeout)
{
nfds = get_max_select_fd(nfds, readfds, writefds, exceptfds);
auto control_blocks = std::unique_ptr<FdControlBlock[]>{ new (std::nothrow) FdControlBlock[nfds] };
if (!control_blocks)
{
errno = ENOMEM;
return -1;
}
size_t fd_count = 0;
rtos::EventFlags flag;
const uint32_t event_flag = 1;
int fd_processed = 0;
// Convert input into FdControlBlock which are more manageable.
for (int i = 0; i < nfds; ++i)
{
auto cb = FdControlBlock(i, readfds, writefds, exceptfds);
if (cb.handle)
{
control_blocks[fd_count] = cb;
++fd_count;
}
}
// Install handler
bool must_wait = true;
for (size_t i = 0; i < fd_count; ++i)
{
auto & cb = control_blocks[i];
if (cb.poll())
{
// One event is set, we don't need to wait to process the FD
must_wait = false;
break;
}
else
{
cb.handle->sigio([&cb, &flag]() {
if (cb.poll())
{
flag.set(event_flag);
}
});
}
}
// Wait operation
if (fd_count && must_wait)
{
if (!timeout)
{
// Wait forever
flag.wait_any(event_flag);
}
else if (timeout->tv_sec || timeout->tv_usec)
{
// wait for the expected
rtos::Kernel::Clock::duration_u32 duration{ timeout->tv_sec * 1000 + timeout->tv_usec / 1000 };
flag.wait_any_for(event_flag, duration);
}
else
{
// No timeout value set and no file descriptor ready, return
// immediately, no fd processed
for (size_t i = 0; i < fd_count; ++i)
{
auto & cb = control_blocks[i];
cb.handle->sigio(nullptr);
}
// Update output file descriptors
for (auto & fds : { readfds, writefds, exceptfds })
{
if (fds)
{
FD_ZERO(fds);
}
}
return fd_processed;
}
}
// Update output file descriptors
for (auto & fds : { readfds, writefds, exceptfds })
{
if (fds)
{
FD_ZERO(fds);
}
}
// Update fds watch and watch list
for (size_t i = 0; i < fd_count; ++i)
{
auto & cb = control_blocks[i];
auto events = cb.poll();
if (cb.read && (events & POLLIN))
{
FD_SET(cb.fd, readfds);
++fd_processed;
}
if (cb.write && (events & POLLOUT))
{
FD_SET(cb.fd, writefds);
++fd_processed;
}
if (cb.err && (events & POLLERR))
{
FD_SET(cb.fd, exceptfds);
++fd_processed;
}
// remove temporary sigio
cb.handle->sigio(nullptr);
}
return fd_processed;
}
int mbed_eventfd(unsigned int initval, int flags)
{
if (initval || flags)
{
return -1;
}
return open_fh_as_fd<EventFileHandle>();
}
int mbed_eventfd_read(int fd, eventfd_t * value)
{
return read(fd, value, sizeof(*value));
}
int mbed_eventfd_write(int fd, eventfd_t value)
{
return write(fd, &value, sizeof(value));
}
| 26.341406 | 139 | 0.562239 | ARMmbed |
a6ea5c5e55d956354df66cdd82a4d506bf043b00 | 2,626 | cpp | C++ | OpenSees/SRC/renderer/db.cpp | kuanshi/ductile-fracture | ccb350564df54f5c5ec3a079100effe261b46650 | [
"MIT"
] | 8 | 2019-03-05T16:25:10.000Z | 2020-04-17T14:12:03.000Z | SRC/renderer/db.cpp | steva44/OpenSees | 417c3be117992a108c6bbbcf5c9b63806b9362ab | [
"TCL"
] | null | null | null | SRC/renderer/db.cpp | steva44/OpenSees | 417c3be117992a108c6bbbcf5c9b63806b9362ab | [
"TCL"
] | 3 | 2019-09-21T03:11:11.000Z | 2020-01-19T07:29:37.000Z | /* ****************************************************************** **
** OpenSees - Open System for Earthquake Engineering Simulation **
** Pacific Earthquake Engineering Research Center **
** **
** **
** (C) Copyright 1999, The Regents of the University of California **
** All Rights Reserved. **
** **
** Commercial use of this program without express permission of the **
** University of California, Berkeley, is strictly prohibited. See **
** file 'COPYRIGHT' in main directory for information on usage and **
** redistribution, and for a DISCLAIMER OF ALL WARRANTIES. **
** **
** Developed by: **
** Frank McKenna (fmckenna@ce.berkeley.edu) **
** Gregory L. Fenves (fenves@ce.berkeley.edu) **
** Filip C. Filippou (filippou@ce.berkeley.edu) **
** **
** ****************************************************************** */
// $Revision: 1.2 $
// $Date: 2003-02-14 23:01:58 $
// $Source: /usr/local/cvs/OpenSees/SRC/renderer/db.cpp,v $
#include <string.h>
#include "db.H"
void
MYPOINT::Transform(MATRIX *M)
{
float a,bb,c,d;
a = p[0] * M->m[0][0] + p[1] * M->m[1][0] + p[2] * M->m[2][0] +
p[3] * M->m[3][0];
bb = p[0] * M->m[0][1] + p[1] * M->m[1][1] + p[2] * M->m[2][1] +
p[3] * M->m[3][1];
c = p[0] * M->m[0][2] + p[1] * M->m[1][2] + p[2] * M->m[2][2] +
p[3] * M->m[3][2];
d = p[0] * M->m[0][3] + p[1] * M->m[1][3] + p[2] * M->m[2][3] +
p[3] * M->m[3][3];
p[0] = a; p[1] = bb; p[2] = c; p[3] = d;
}
OPS_Stream &operator<<(OPS_Stream &os, MYPOINT &point)
{
os <<"Point ("<<point.X()<<' '<<point.Y()<<' '<<
point.Z()<<')';
os << " (" << point.r << ' ' << point.g << ' ' << point.b << " )";
return os;
}
OPS_Stream &operator<<(OPS_Stream &os, FACE &face)
{
os <<"Face: "<< endln;
MYPOINT *point;
FOR_EACH(point, face.pointList)
{
os << (*point) << endln;
}
return os;
}
| 40.4 | 72 | 0.353008 | kuanshi |
a6eb023906b4bc6df26ebf5d31be5d6cf5e49212 | 648 | cpp | C++ | problems/codeforces/1504/b-flip-the-bits/code.cpp | brunodccarvalho/competitive | 4177c439174fbe749293b9da3445ce7303bd23c2 | [
"MIT"
] | 7 | 2020-10-15T22:37:10.000Z | 2022-02-26T17:23:49.000Z | problems/codeforces/1504/b-flip-the-bits/code.cpp | brunodccarvalho/competitive | 4177c439174fbe749293b9da3445ce7303bd23c2 | [
"MIT"
] | null | null | null | problems/codeforces/1504/b-flip-the-bits/code.cpp | brunodccarvalho/competitive | 4177c439174fbe749293b9da3445ce7303bd23c2 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
// *****
auto solve() {
int N;
string a, b;
cin >> N >> a >> b;
bool eq = true;
int ones = count(begin(a), end(a), '1');
int zeros = N - ones;
for (int i = N - 1; i >= 0; i--) {
bool same = (a[i] == b[i]) == eq;
if (!same && ones != zeros) {
return "NO";
}
a[i] == '1' ? ones-- : zeros--;
eq ^= !same;
}
return "YES";
}
// *****
int main() {
ios::sync_with_stdio(false);
unsigned T;
cin >> T >> ws;
for (unsigned t = 1; t <= T; ++t) {
cout << solve() << endl;
}
return 0;
}
| 16.615385 | 44 | 0.405864 | brunodccarvalho |
a6ebcbad9e9e3e377c2d3a8ed595b32dcc98fce4 | 284,460 | cpp | C++ | App/Il2CppOutputProject/Source/il2cppOutput/Assembly-CSharp_Attr.cpp | JBrentJ/MRDL_Unity_Surfaces | 155c97eb7803af90ef1b7e95dfe7969694507575 | [
"MIT"
] | null | null | null | App/Il2CppOutputProject/Source/il2cppOutput/Assembly-CSharp_Attr.cpp | JBrentJ/MRDL_Unity_Surfaces | 155c97eb7803af90ef1b7e95dfe7969694507575 | [
"MIT"
] | null | null | null | App/Il2CppOutputProject/Source/il2cppOutput/Assembly-CSharp_Attr.cpp | JBrentJ/MRDL_Unity_Surfaces | 155c97eb7803af90ef1b7e95dfe7969694507575 | [
"MIT"
] | null | null | null | #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;
// System.Type[]
struct TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755;
// System.Runtime.CompilerServices.AsyncStateMachineAttribute
struct AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6;
// System.Reflection.Binder
struct Binder_t2BEE27FD84737D1E79BC47FD67F6D3DD2F2DDA30;
// System.Runtime.CompilerServices.CompilationRelaxationsAttribute
struct CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF;
// System.Runtime.CompilerServices.CompilerGeneratedAttribute
struct CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C;
// System.Diagnostics.DebuggableAttribute
struct DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B;
// System.Diagnostics.DebuggerHiddenAttribute
struct DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88;
// UnityEngine.ExecuteInEditMode
struct ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173;
// UnityEngine.HeaderAttribute
struct HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB;
// UnityEngine.HideInInspector
struct HideInInspector_tDD5B9D3AD8D48C93E23FE6CA3ECDA5589D60CCDA;
// System.Reflection.MemberFilter
struct MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81;
// UnityEngine.RangeAttribute
struct RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5;
// System.Runtime.CompilerServices.RuntimeCompatibilityAttribute
struct RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80;
// UnityEngine.SerializeField
struct SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25;
// System.String
struct String_t;
// UnityEngine.TooltipAttribute
struct TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B;
// System.Type
struct Type_t;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
IL2CPP_EXTERN_C const RuntimeType* U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_0_0_0_var;
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
// System.Object
// System.Attribute
struct Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71 : public RuntimeObject
{
public:
public:
};
// System.Reflection.MemberInfo
struct MemberInfo_t : 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.Runtime.CompilerServices.CompilationRelaxationsAttribute
struct CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Int32 System.Runtime.CompilerServices.CompilationRelaxationsAttribute::m_relaxations
int32_t ___m_relaxations_0;
public:
inline static int32_t get_offset_of_m_relaxations_0() { return static_cast<int32_t>(offsetof(CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF, ___m_relaxations_0)); }
inline int32_t get_m_relaxations_0() const { return ___m_relaxations_0; }
inline int32_t* get_address_of_m_relaxations_0() { return &___m_relaxations_0; }
inline void set_m_relaxations_0(int32_t value)
{
___m_relaxations_0 = value;
}
};
// System.Runtime.CompilerServices.CompilerGeneratedAttribute
struct CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.Diagnostics.DebuggerHiddenAttribute
struct DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// 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
{
};
// UnityEngine.ExecuteInEditMode
struct ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// UnityEngine.HideInInspector
struct HideInInspector_tDD5B9D3AD8D48C93E23FE6CA3ECDA5589D60CCDA : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// 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.PropertyAttribute
struct PropertyAttribute_t4A352471DF625C56C811E27AC86B7E1CE6444052 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.Runtime.CompilerServices.RuntimeCompatibilityAttribute
struct RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Boolean System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::m_wrapNonExceptionThrows
bool ___m_wrapNonExceptionThrows_0;
public:
inline static int32_t get_offset_of_m_wrapNonExceptionThrows_0() { return static_cast<int32_t>(offsetof(RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80, ___m_wrapNonExceptionThrows_0)); }
inline bool get_m_wrapNonExceptionThrows_0() const { return ___m_wrapNonExceptionThrows_0; }
inline bool* get_address_of_m_wrapNonExceptionThrows_0() { return &___m_wrapNonExceptionThrows_0; }
inline void set_m_wrapNonExceptionThrows_0(bool value)
{
___m_wrapNonExceptionThrows_0 = value;
}
};
// UnityEngine.SerializeField
struct SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.Runtime.CompilerServices.StateMachineAttribute
struct StateMachineAttribute_tA6E77C77F821508E405473BA1C4C08A69FDA0AC3 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Type System.Runtime.CompilerServices.StateMachineAttribute::<StateMachineType>k__BackingField
Type_t * ___U3CStateMachineTypeU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CStateMachineTypeU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(StateMachineAttribute_tA6E77C77F821508E405473BA1C4C08A69FDA0AC3, ___U3CStateMachineTypeU3Ek__BackingField_0)); }
inline Type_t * get_U3CStateMachineTypeU3Ek__BackingField_0() const { return ___U3CStateMachineTypeU3Ek__BackingField_0; }
inline Type_t ** get_address_of_U3CStateMachineTypeU3Ek__BackingField_0() { return &___U3CStateMachineTypeU3Ek__BackingField_0; }
inline void set_U3CStateMachineTypeU3Ek__BackingField_0(Type_t * value)
{
___U3CStateMachineTypeU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CStateMachineTypeU3Ek__BackingField_0), (void*)value);
}
};
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5
{
public:
union
{
struct
{
};
uint8_t Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5__padding[1];
};
public:
};
// System.Runtime.CompilerServices.AsyncStateMachineAttribute
struct AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 : public StateMachineAttribute_tA6E77C77F821508E405473BA1C4C08A69FDA0AC3
{
public:
public:
};
// System.Reflection.BindingFlags
struct BindingFlags_tAAAB07D9AC588F0D55D844E51D7035E96DF94733
{
public:
// System.Int32 System.Reflection.BindingFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(BindingFlags_tAAAB07D9AC588F0D55D844E51D7035E96DF94733, ___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.HeaderAttribute
struct HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB : public PropertyAttribute_t4A352471DF625C56C811E27AC86B7E1CE6444052
{
public:
// System.String UnityEngine.HeaderAttribute::header
String_t* ___header_0;
public:
inline static int32_t get_offset_of_header_0() { return static_cast<int32_t>(offsetof(HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB, ___header_0)); }
inline String_t* get_header_0() const { return ___header_0; }
inline String_t** get_address_of_header_0() { return &___header_0; }
inline void set_header_0(String_t* value)
{
___header_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___header_0), (void*)value);
}
};
// UnityEngine.RangeAttribute
struct RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 : public PropertyAttribute_t4A352471DF625C56C811E27AC86B7E1CE6444052
{
public:
// System.Single UnityEngine.RangeAttribute::min
float ___min_0;
// System.Single UnityEngine.RangeAttribute::max
float ___max_1;
public:
inline static int32_t get_offset_of_min_0() { return static_cast<int32_t>(offsetof(RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5, ___min_0)); }
inline float get_min_0() const { return ___min_0; }
inline float* get_address_of_min_0() { return &___min_0; }
inline void set_min_0(float value)
{
___min_0 = value;
}
inline static int32_t get_offset_of_max_1() { return static_cast<int32_t>(offsetof(RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5, ___max_1)); }
inline float get_max_1() const { return ___max_1; }
inline float* get_address_of_max_1() { return &___max_1; }
inline void set_max_1(float value)
{
___max_1 = value;
}
};
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9
{
public:
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// UnityEngine.TooltipAttribute
struct TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B : public PropertyAttribute_t4A352471DF625C56C811E27AC86B7E1CE6444052
{
public:
// System.String UnityEngine.TooltipAttribute::tooltip
String_t* ___tooltip_0;
public:
inline static int32_t get_offset_of_tooltip_0() { return static_cast<int32_t>(offsetof(TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B, ___tooltip_0)); }
inline String_t* get_tooltip_0() const { return ___tooltip_0; }
inline String_t** get_address_of_tooltip_0() { return &___tooltip_0; }
inline void set_tooltip_0(String_t* value)
{
___tooltip_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___tooltip_0), (void*)value);
}
};
// System.Diagnostics.DebuggableAttribute/DebuggingModes
struct DebuggingModes_t279D5B9C012ABA935887CB73C5A63A1F46AF08A8
{
public:
// System.Int32 System.Diagnostics.DebuggableAttribute/DebuggingModes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DebuggingModes_t279D5B9C012ABA935887CB73C5A63A1F46AF08A8, ___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;
}
};
// System.Diagnostics.DebuggableAttribute
struct DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Diagnostics.DebuggableAttribute/DebuggingModes System.Diagnostics.DebuggableAttribute::m_debuggingModes
int32_t ___m_debuggingModes_0;
public:
inline static int32_t get_offset_of_m_debuggingModes_0() { return static_cast<int32_t>(offsetof(DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B, ___m_debuggingModes_0)); }
inline int32_t get_m_debuggingModes_0() const { return ___m_debuggingModes_0; }
inline int32_t* get_address_of_m_debuggingModes_0() { return &___m_debuggingModes_0; }
inline void set_m_debuggingModes_0(int32_t value)
{
___m_debuggingModes_0 = value;
}
};
// System.Type
struct Type_t : public MemberInfo_t
{
public:
// System.RuntimeTypeHandle System.Type::_impl
RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 ____impl_9;
public:
inline static int32_t get_offset_of__impl_9() { return static_cast<int32_t>(offsetof(Type_t, ____impl_9)); }
inline RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 get__impl_9() const { return ____impl_9; }
inline RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 * get_address_of__impl_9() { return &____impl_9; }
inline void set__impl_9(RuntimeTypeHandle_tC33965ADA3E041E0C94AF05E5CB527B56482CEF9 value)
{
____impl_9 = value;
}
};
struct Type_t_StaticFields
{
public:
// System.Reflection.MemberFilter System.Type::FilterAttribute
MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * ___FilterAttribute_0;
// System.Reflection.MemberFilter System.Type::FilterName
MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * ___FilterName_1;
// System.Reflection.MemberFilter System.Type::FilterNameIgnoreCase
MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * ___FilterNameIgnoreCase_2;
// System.Object System.Type::Missing
RuntimeObject * ___Missing_3;
// System.Char System.Type::Delimiter
Il2CppChar ___Delimiter_4;
// System.Type[] System.Type::EmptyTypes
TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* ___EmptyTypes_5;
// System.Reflection.Binder System.Type::defaultBinder
Binder_t2BEE27FD84737D1E79BC47FD67F6D3DD2F2DDA30 * ___defaultBinder_6;
public:
inline static int32_t get_offset_of_FilterAttribute_0() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterAttribute_0)); }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * get_FilterAttribute_0() const { return ___FilterAttribute_0; }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 ** get_address_of_FilterAttribute_0() { return &___FilterAttribute_0; }
inline void set_FilterAttribute_0(MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * value)
{
___FilterAttribute_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterAttribute_0), (void*)value);
}
inline static int32_t get_offset_of_FilterName_1() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterName_1)); }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * get_FilterName_1() const { return ___FilterName_1; }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 ** get_address_of_FilterName_1() { return &___FilterName_1; }
inline void set_FilterName_1(MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * value)
{
___FilterName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterName_1), (void*)value);
}
inline static int32_t get_offset_of_FilterNameIgnoreCase_2() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterNameIgnoreCase_2)); }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * get_FilterNameIgnoreCase_2() const { return ___FilterNameIgnoreCase_2; }
inline MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 ** get_address_of_FilterNameIgnoreCase_2() { return &___FilterNameIgnoreCase_2; }
inline void set_FilterNameIgnoreCase_2(MemberFilter_t48D0AA10105D186AF42428FA532D4B4332CF8B81 * value)
{
___FilterNameIgnoreCase_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterNameIgnoreCase_2), (void*)value);
}
inline static int32_t get_offset_of_Missing_3() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Missing_3)); }
inline RuntimeObject * get_Missing_3() const { return ___Missing_3; }
inline RuntimeObject ** get_address_of_Missing_3() { return &___Missing_3; }
inline void set_Missing_3(RuntimeObject * value)
{
___Missing_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Missing_3), (void*)value);
}
inline static int32_t get_offset_of_Delimiter_4() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Delimiter_4)); }
inline Il2CppChar get_Delimiter_4() const { return ___Delimiter_4; }
inline Il2CppChar* get_address_of_Delimiter_4() { return &___Delimiter_4; }
inline void set_Delimiter_4(Il2CppChar value)
{
___Delimiter_4 = value;
}
inline static int32_t get_offset_of_EmptyTypes_5() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___EmptyTypes_5)); }
inline TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* get_EmptyTypes_5() const { return ___EmptyTypes_5; }
inline TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755** get_address_of_EmptyTypes_5() { return &___EmptyTypes_5; }
inline void set_EmptyTypes_5(TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* value)
{
___EmptyTypes_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___EmptyTypes_5), (void*)value);
}
inline static int32_t get_offset_of_defaultBinder_6() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___defaultBinder_6)); }
inline Binder_t2BEE27FD84737D1E79BC47FD67F6D3DD2F2DDA30 * get_defaultBinder_6() const { return ___defaultBinder_6; }
inline Binder_t2BEE27FD84737D1E79BC47FD67F6D3DD2F2DDA30 ** get_address_of_defaultBinder_6() { return &___defaultBinder_6; }
inline void set_defaultBinder_6(Binder_t2BEE27FD84737D1E79BC47FD67F6D3DD2F2DDA30 * value)
{
___defaultBinder_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___defaultBinder_6), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Void System.Diagnostics.DebuggableAttribute::.ctor(System.Diagnostics.DebuggableAttribute/DebuggingModes)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DebuggableAttribute__ctor_m7FF445C8435494A4847123A668D889E692E55550 (DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B * __this, int32_t ___modes0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CompilationRelaxationsAttribute__ctor_mAC3079EBC4EEAB474EED8208EF95DB39C922333B (CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF * __this, int32_t ___relaxations0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute__ctor_m551DDF1438CE97A984571949723F30F44CF7317C (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::set_WrapNonExceptionThrows(System.Boolean)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, bool ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.SerializeField::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3 (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * __this, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35 (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * __this, const RuntimeMethod* method);
// System.Void UnityEngine.HeaderAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * __this, String_t* ___header0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.AsyncStateMachineAttribute::.ctor(System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * __this, Type_t * ___stateMachineType0, const RuntimeMethod* method);
// System.Void System.Diagnostics.DebuggerHiddenAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3 (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.HideInInspector::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void HideInInspector__ctor_mE2B7FB1D206A74BA583C7812CDB4EBDD83EB66F9 (HideInInspector_tDD5B9D3AD8D48C93E23FE6CA3ECDA5589D60CCDA * __this, const RuntimeMethod* method);
// System.Void UnityEngine.RangeAttribute::.ctor(System.Single,System.Single)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000 (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * __this, float ___min0, float ___max1, const RuntimeMethod* method);
// System.Void UnityEngine.ExecuteInEditMode::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ExecuteInEditMode__ctor_m52849B67DB46F6CF090D45E523FAE97A10825C0A (ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.TooltipAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TooltipAttribute__ctor_m1839ACEC1560968A6D0EA55D7EB4535546588042 (TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B * __this, String_t* ___tooltip0, const RuntimeMethod* method);
static void AssemblyU2DCSharp_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B * tmp = (DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B *)cache->attributes[0];
DebuggableAttribute__ctor_m7FF445C8435494A4847123A668D889E692E55550(tmp, 2LL, NULL);
}
{
CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF * tmp = (CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF *)cache->attributes[1];
CompilationRelaxationsAttribute__ctor_mAC3079EBC4EEAB474EED8208EF95DB39C922333B(tmp, 8LL, NULL);
}
{
RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * tmp = (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 *)cache->attributes[2];
RuntimeCompatibilityAttribute__ctor_m551DDF1438CE97A984571949723F30F44CF7317C(tmp, NULL);
RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline(tmp, true, NULL);
}
}
static void ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_loadSceneMode(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_contentName(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_loadOnKeyPress(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_keyCode(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_ButtonLoadContentScene_U3CLoadContentU3Eb__5_0_m0F2BAB71C442DA2D6DD2175FA2F624413388AEA3(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CU3Ec_t43FDE974E52D7C6CDA8B25128E2467049C5C3F2D_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipRadius(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x48\x65\x61\x74"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatDissipateSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatGainSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatRadiusMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numWisps(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x57\x69\x73\x70\x73"), NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_seekStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_velocityDampen(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_initialVelocity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_offsetMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_colorCycleSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_baseWispColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatWispColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispMat(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_ambientNoise(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_agitatedNoise(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipVelocityColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x46\x69\x6E\x67\x65\x72\x74\x69\x70\x73"), NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionPitch(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionFadeSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numTiles(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x54\x65\x78\x74\x75\x72\x65\x20\x74\x69\x6C\x69\x6E\x67"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numColumns(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numRows(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_tileScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_tileOffsets(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_currentTileNum(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_Ephemeral_UpdateWispsTask_m6394F82B466F3D9C7A5C8C4B86D557B9A6AE04A3(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_0_0_0_var), NULL);
}
}
static void Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_Ephemeral_UpdateWisps_m07B2A1316E992F0C63DE9164CFDE0A991940571C(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_0_0_0_var), NULL);
}
}
static void U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_CustomAttributesCacheGenerator_U3CUpdateWispsTaskU3Ed__59_SetStateMachine_mF28B0A6C88891567ED86C4A0214C1E0B3BE12A30(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CU3Ec_t49911D0DBBA0A1916E776BDF2D6019A9A05B514B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_CustomAttributesCacheGenerator_U3CUpdateWispsU3Ed__66_SetStateMachine_m418F25120B4C81FA7CE82086B2A6CBC48237D287(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_U3CInitializedU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_U3CSurfacePositionU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingers(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x46\x69\x6E\x67\x65\x72\x20\x6F\x62\x6A\x65\x63\x74\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palms(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_disableInactiveFingersInEditor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingerRigidBodies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x46\x69\x6E\x67\x65\x72\x20\x50\x68\x79\x73\x69\x63\x73"), NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingerColliders(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palmRigidBodies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palmColliders(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_surfaceTransform(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x53\x75\x72\x66\x61\x63\x65"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_get_Initialized_m8BCDDB4DF79FBFA9051F901D8701830BA8739FA4(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_set_Initialized_m468F44FAA1F96A6E5422A0A8123D4895E4329D4B(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_get_SurfacePosition_mF548C1A7C23931BC08953F30F9227B6265140028(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_set_SurfacePosition_m1ED8F1CEEBA5BC94A4A2AFDEC15789CCC480D5E2(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_sampler(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_oceanCollider(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_numBoids(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_coherenceAmount(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_alignmentAmount(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_separationAmount(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_fleeAmount(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_maxSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_maxForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_minDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidRespawnTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_surfaceBounce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_surfaceBounceSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_agitationMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_forceRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_splashPrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_bounceCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_flockRotate(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_normalAudio(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_fleeingAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_masterVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_audioChangeSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_numBoidsFleeingMaxVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidMesh(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidMat(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_positionMap(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_flock(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_asteroids(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_impactPrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_explosionRespawnDelay(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_collisionTimeoutDelay(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_despawnedMaterial(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_despawnedGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_sampler(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_minRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_agitationForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_radiusChangeSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_gravity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_blendShapeCurves(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x6F\x6F\x70\x20\x43\x65\x6E\x74\x65\x72"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopCenter(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerGlowGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerPoppedGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerGlowCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerPoppedCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerSquirmCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopBlorbPrefabs(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x6F\x6F\x70\x20\x42\x6C\x6F\x72\x62\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_bloatGradientEmission(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_bloatGradientColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_poppedGradientColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_baseGradientColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxDistToFinger(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxBloatBeforePop(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_respawnTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerAgitationCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popRecoveryCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popRecoveryScaleCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_emissionColorPropName(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTips(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x46\x69\x6E\x67\x65\x72\x74\x69\x70\x73"), NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTipSlimeFadeSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTipSlimeColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopDistance(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x6F\x6F\x70\x20\x53\x6C\x69\x6D\x65"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopSlimes(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_timeLastPopped(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosPitch(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_rotationSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_Goop_UpdateBlorbsLoop_m986AFC428EF64DB53EC5976F8BF9E8CBBC48E415(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_0_0_0_var), NULL);
}
}
static void Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_Goop_UpdateBlorbs_mABD7F7D7F1A0B432F4FD89D33896F0AADDE82D0A(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_0_0_0_var), NULL);
}
}
static void U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_CustomAttributesCacheGenerator_U3CUpdateBlorbsLoopU3Ed__58_SetStateMachine_m0AD947925371163FB699FEAB47B3860A98A38222(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_CustomAttributesCacheGenerator_U3CUpdateBlorbsU3Ed__59_SetStateMachine_mC0A06B4D05DD9C12B90C278C353AB2DDC3BEB13A(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void GoopBlorb_t9629F618A80F58AC7278B62806B18766CED5F62E_CustomAttributesCacheGenerator_meshRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_lineRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_maxStretch(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_minWidth(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_maxWidth(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_droopSpeedCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_droopCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_widthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_followCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_origin(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_target(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inertia(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x50\x68\x79\x73\x69\x63\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_targetSeekStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inertiaStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inheritedStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_gravityStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_growbies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_fingerInfluence(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonRevertSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonChangeSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonTargets(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_mainLightColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_overallSeason(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_growbieParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_winterAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_winterAudioCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_summerAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_summerAudioCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_masterVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftHandObject(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x48\x61\x6E\x64\x20\x4F\x62\x6A\x65\x63\x74\x73"), NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightHandObject(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftHandRoot(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightHandRoot(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftJointMaps(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightJointMaps(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftJointRotOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightJointRotOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void JointMap_tCEC1674D0AC1373CD1630729F0EBE75F01E7E1BF_CustomAttributesCacheGenerator_Transform(CustomAttributesCache* cache)
{
{
HideInInspector_tDD5B9D3AD8D48C93E23FE6CA3ECDA5589D60CCDA * tmp = (HideInInspector_tDD5B9D3AD8D48C93E23FE6CA3ECDA5589D60CCDA *)cache->attributes[0];
HideInInspector__ctor_mE2B7FB1D206A74BA583C7812CDB4EBDD83EB66F9(tmp, NULL);
}
}
static void HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJoints(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4A\x6F\x69\x6E\x74\x20\x6F\x62\x6A\x65\x63\x74\x73"), NULL);
}
}
static void HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJointRigidBodies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJointColliders(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_chunks(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_initialImpulseForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingerForceDist(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingerPushForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_innerCollider(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatIncreaseSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x48\x65\x61\x74"), NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatDecreaseSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingertipHeatColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_baseColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_minTimeBetweenImpacts(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_impactClips(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_volumeCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_lavaBubbles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x42\x75\x62\x62\x6C\x65\x73"), NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_bubbleDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_spawnOdds(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_bubbleCheckRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_chunkLayer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_lavaMat(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4C\x61\x76\x61"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_scrollSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_impactParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_U3COnCollisionU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_U3CSubmergedAmountU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_gravityTarget(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_particles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_particlesPrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_get_OnCollision_mD08DBDB130307B7476EE0048AA1FFA5D09C63E56(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_set_OnCollision_m81FA4F0500DD9C2430CFEF95463FF07F9875F661(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_get_SubmergedAmount_mE70C23EA381F4A29EE98CD18417041DA5691FFFF(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_set_SubmergedAmount_m3198E1F1B5D613F134A0A1E1326CFAAC9D204A55(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_lineRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point1Particles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point2Particles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point1(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point2(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_jitter(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4E\x6F\x69\x73\x65"), NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_maxLightIntensity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_noiseScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_noiseSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_minWidth(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x57\x69\x64\x74\x68"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_maxWidth(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_widthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_boltTextures(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_fingerAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_jitterCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_point1Light(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_U3CPoint1SampleIndexU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_FingerArc_get_Point1SampleIndex_mD059D02CE72FF48BC3C2CA82E407BA4B6AC86961(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_FingerArc_set_Point1SampleIndex_mCC2A0AC52480743A3E885AA86B978ADA556ADD15(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_sampler(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_surfaceArcs(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerArcs(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerArcSources(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_randomSurfaceArcChange(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_randomFingerArcChange(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerEngageDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerRandomPosRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerDisengageDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_glowGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_coreRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_glowSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_intensityCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_flickerCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_buzzAudioPitch(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_buzzAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_gravityCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_gravityResetCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_arcEscapeStrength(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void LoadFirstScene_tB15D9B41665EB1A9BC1BB9B1A563C5458D6FBE7C_CustomAttributesCacheGenerator_contentName(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_mesh(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_numPointsToSample(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapResX(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapResY(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapUvTest(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapTriIndexTest(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_uvChannel(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 1.0f, 8.0f, NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Tutorial_t00E576E62CB1B76A4CEB914E180C4F6F2CC63BF3_CustomAttributesCacheGenerator_holdUpPalmText(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Tutorial_t00E576E62CB1B76A4CEB914E180C4F6F2CC63BF3_CustomAttributesCacheGenerator_menu(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CChunkImpactIntensityU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CFingerImpactIntensityU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3COnImpactU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastOtherColliderU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastImpactIntensityU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastImpactTypeU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CRadiusU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_impactAudio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_ChunkImpactIntensity_m1807D63C5B630D450B3E2AEA29AEB5A1E8FDACE2(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_ChunkImpactIntensity_m927159F8F8B2FD7FC95FB03F58B8F57921010FAB(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_FingerImpactIntensity_m1CE7563DEEAB831F2C036A4DFFBC11633B9BB7B3(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_FingerImpactIntensity_m220556FA6D06D229B034F68B2989B2334639F973(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_OnImpact_mE14A44BE107C2E33241E312F948D20131BF6C860(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_OnImpact_m6422199BF7D8E1D4E0A54A7FE2AB6D6B5F72385A(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastOtherCollider_m2520C1755860A6DD8492BB447C3BF4C7F9EE75EE(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastOtherCollider_mA41C25E5C29C769AA31E61E6A206C99761FCE55B(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastImpactIntensity_m1DD1F66AB5B866394039424880BD2B378DDC6DDF(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastImpactIntensity_mF69C6DD25806A0693390F08B708922DDE2D81766(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastImpactType_m8FC0B9188E2B96205BF90677F63604DE47F79FF7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastImpactType_mB778B2D8B59D0ACD1CF5AA6C22FC0E0ACED9C5E9(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_Radius_m5705FDA4CE6B0711DD0DC0CBD6AFC799B1BA2E04(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_Radius_mD01BBBEB17A03805057D50AB3804A10556E8CF6C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_volumePrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_centralParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0Core(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x65\x6E\x20\x30"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0Surface(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_coreRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0RadiusMin(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0RadiusMax(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1Count(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x65\x6E\x20\x31"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1RadiusMin(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1RadiusMax(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2Count(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x65\x6E\x20\x32"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2RadiusMin(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2RadiusMax(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3Count(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x65\x6E\x20\x33"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3RadiusMin(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3RadiusMax(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionColor(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_linePrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen1(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen2(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen3(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftIntensity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x50\x68\x79\x73\x69\x63\x73"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftTimeScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_seekForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactClips(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactClip(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactGradient(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x49\x6D\x70\x61\x63\x74\x20\x43\x6F\x6C\x6F\x72\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_volumeImpactGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_chunkImpactFadeTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactFadeTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_baseFingerColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_drawConnections(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_minImpactParticleIntensity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_audio(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_domeRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_burstRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_coneRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_soundWaveRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_animator(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notesTransforms(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notes(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notePrefab(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_noteParent(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_noteData(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4E\x6F\x74\x65\x20\x44\x61\x74\x61"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedGradient(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4E\x6F\x74\x65\x20\x41\x6E\x69\x6D\x61\x74\x69\x6F\x6E"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedGradient(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedPosCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedPosCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releaseAnimationDuration(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_timeBetweenNoteReleases(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_emissiveColorName(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_emissiveColorNameBurst(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_albedorColorName(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_defaultOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_maxRepositionDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_useSpatialUnderstanding(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_moveIncrement(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_timeOut(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_spatialAwarenessMask(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_SurfacePlacement_PlaceNewSurface_m47ED70EFEA4C987DCBC1C592096F26A955649D30(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_0_0_0_var), NULL);
}
}
static void U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_CustomAttributesCacheGenerator_U3CPlaceNewSurfaceU3Ed__14_SetStateMachine_m615B0FC5AC8486760391A9390B0CA1950CDBED30(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 * tmp = (ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 *)cache->attributes[0];
ExecuteInEditMode__ctor_m52849B67DB46F6CF090D45E523FAE97A10825C0A(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_zOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotate(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotateSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotateOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_randomScaleOffset(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_fingerForce(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleDriftSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleReturnSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleTransform(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubble(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_controller(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_enterBubbleClips(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_touchBubbleCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleTouchParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_RadiusMultiplier(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, -0.899999976f, 4.0f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_TurbulenceMultiplier(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 0.100000001f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_TurbulenceSpeed(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 10.0f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Transparency(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Gaze(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Highlight(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Freeze(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_U3COnEnterBubbleU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_U3COnExitBubbleU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x61\x69\x6E\x20\x53\x65\x74\x74\x69\x6E\x67\x73"), NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radiusMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_useVertexNoise(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_useVertexColors(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_defaultVertexColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_meshFilter(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x52\x65\x6E\x64\x65\x72\x69\x6E\x67"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_meshRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_recursionLevel(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_normalAngle(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceCurve(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x46\x6F\x72\x63\x65\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceInertia(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceInertia(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceInertia(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x54\x75\x72\x62\x75\x6C\x65\x6E\x63\x65"), NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbles(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x49\x6E\x6E\x65\x72\x20\x62\x75\x62\x62\x6C\x65\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_minInnerBubbleRadius(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_solidity(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_drawForces(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x69\x7A\x6D\x6F\x73"), NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_forceDrawSkipInterval(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_get_OnEnterBubble_mEBAAF8051AF84AD702109C8DB043CBC54C631535(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_set_OnEnterBubble_mC594F6A0CED6CE8CDF9ED0D0BDE82DCB89D819D3(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_get_OnExitBubble_m5AB5A4AF0C1CC2CF076F46389E87A9BF08730FEE(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_set_OnExitBubble_mF4AF58A854FA5F7455E5EE4BB8287A38234A9DB2(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_UpdateBubbleAsync_mDAAA6DA5F82218CE51E52EFBDF394DA10C479C13(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
{
AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 * tmp = (AsyncStateMachineAttribute_tBDB4B958CFB5CD3BEE1427711FFC8C358C9BA6E6 *)cache->attributes[0];
AsyncStateMachineAttribute__ctor_m9530B59D9722DE383A1703C52EBC1ED1FEFB100B(tmp, il2cpp_codegen_type_get_object(U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_0_0_0_var), NULL);
}
}
static void U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_CustomAttributesCacheGenerator_U3CUpdateBubbleAsyncU3Ed__85_SetStateMachine_m4EC7E00BED36B10F0784AD5438EA19DC94E1E7EB(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_drawTrails(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailProps(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trails(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailBubbleInertia(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailBubbleForceMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 * tmp = (ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 *)cache->attributes[0];
ExecuteInEditMode__ctor_m52849B67DB46F6CF090D45E523FAE97A10825C0A(tmp, NULL);
}
}
static void ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatInterval(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatBlendTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatBlendCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_U3CActivatedOnceU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_animationTarget(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_openCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_closeCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_disableDistance(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_ContextualHandMenu_get_ActivatedOnce_mCDD4C36FFEFB15172240B6C5FD5B6107D9B18268(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_ContextualHandMenu_set_ActivatedOnce_m62012EFA052D5827C098DCD179B984C23FA3CB6D(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_U3CTargetPositionU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_U3CExplodedPositionU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_asteroidRenderer(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLight(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_trailTargetTime(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_rotationSpeed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLightExplosionColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLightNormalColor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_growthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_audioSource(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_impactClip(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_respawnClip(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_impactVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_respawnVolume(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_despawnedMaterial(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_spawnedMaterial(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_get_TargetPosition_m78214B3808F7828BD598FF785EBDD855654E7690(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_set_TargetPosition_m45C00CD43AE53FAFD099F9E6B1CFA1309C2A1571(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_get_ExplodedPosition_m1692B2FBC824BF23849E1556D6C68B94E4B09667(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_set_ExplodedPosition_m8F5C92828EF2D194FBCC878FD55C700E2E539381(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_neutralParticles(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x50\x61\x72\x74\x69\x63\x6C\x65\x73"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_winterParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_summerParticles(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_emissionRate(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_neutralEmissionCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_winterEmissionCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_summerEmissionCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 * tmp = (ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 *)cache->attributes[0];
ExecuteInEditMode__ctor_m52849B67DB46F6CF090D45E523FAE97A10825C0A(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_Season(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x6E\x69\x6D\x61\x74\x65\x64\x20\x46\x69\x65\x6C\x64\x73"), NULL);
}
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[1];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_ChangeSpeed(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 1.0f, 10.0f, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_influenceCenter(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterGrowbies(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4E\x6F\x72\x6D\x61\x6C\x20\x47\x72\x6F\x77\x62\x69\x65\x73\x20\x28\x76\x69\x73\x69\x62\x6C\x65\x20\x61\x74\x20\x61\x6C\x6C\x20\x74\x69\x6D\x65\x73\x29"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_neutralGrowbies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerGrowbies(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterGrowthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x47\x72\x6F\x77\x74\x68\x20\x63\x75\x72\x76\x65\x73"), NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_neutralGrowthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerGrowthCurve(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterClips(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x75\x64\x69\x6F"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerClips(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_audioSource(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_volumeMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 * tmp = (ExecuteInEditMode_tAA3B5DE8B7E207BC6CAAFDB1F2502350C0546173 *)cache->attributes[0];
ExecuteInEditMode__ctor_m52849B67DB46F6CF090D45E523FAE97A10825C0A(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_U3CIsDirtyU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growth(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[1];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x41\x6E\x69\x6D\x61\x74\x65\x64\x20\x50\x61\x72\x61\x6D\x65\x74\x65\x72\x73"), NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthRandomness(CustomAttributesCache* cache)
{
{
TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B * tmp = (TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B *)cache->attributes[0];
TooltipAttribute__ctor_m1839ACEC1560968A6D0EA55D7EB4535546588042(tmp, il2cpp_codegen_string_new_wrapper("\x52\x61\x6E\x64\x6F\x6D\x20\x76\x61\x6C\x75\x65\x73\x20\x64\x65\x74\x65\x72\x6D\x69\x6E\x65\x64\x20\x62\x79\x20\x73\x65\x65\x64"), NULL);
}
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[1];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[2];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[3];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x53\x74\x61\x74\x69\x63\x20\x50\x61\x72\x61\x6D\x65\x74\x65\x72\x73"), NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthJitter(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthScaleMultiplier(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
{
TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B * tmp = (TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B *)cache->attributes[1];
TooltipAttribute__ctor_m1839ACEC1560968A6D0EA55D7EB4535546588042(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x75\x6C\x74\x69\x70\x6C\x69\x65\x72\x20\x66\x6F\x72\x20\x73\x63\x61\x6C\x65\x20\x6F\x66\x20\x74\x72\x61\x6E\x73\x66\x6F\x72\x6D\x73\x20\x69\x6E\x20\x68\x65\x69\x72\x61\x72\x63\x68\x79\x20\x66\x72\x6F\x6D\x20\x66\x69\x72\x73\x74\x20\x74\x6F\x20\x6C\x61\x73\x74"), NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkScrewAmount(CustomAttributesCache* cache)
{
{
TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B * tmp = (TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B *)cache->attributes[0];
TooltipAttribute__ctor_m1839ACEC1560968A6D0EA55D7EB4535546588042(tmp, il2cpp_codegen_string_new_wrapper("\x48\x6F\x77\x20\x6D\x75\x63\x68\x20\x74\x68\x65\x20\x67\x72\x6F\x77\x62\x69\x65\x73\x20\x72\x6F\x74\x61\x74\x65\x20\x6F\x6E\x20\x74\x68\x65\x69\x72\x20\x59\x20\x61\x78\x69\x73\x20\x61\x73\x20\x74\x68\x65\x79\x20\x67\x72\x6F\x77"), NULL);
}
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[1];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 0.0f, 1.0f, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkscrewJitter(CustomAttributesCache* cache)
{
{
RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 * tmp = (RangeAttribute_t14A6532D68168764C15E7CF1FDABCD99CB32D0C5 *)cache->attributes[0];
RangeAttribute__ctor_mC74D39A9F20DD2A0D4174F05785ABE4F0DAEF000(tmp, 1.0f, 20.0f, NULL);
}
{
TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B * tmp = (TooltipAttribute_t503A1598A4E68E91673758F50447D0EDFB95149B *)cache->attributes[1];
TooltipAttribute__ctor_m1839ACEC1560968A6D0EA55D7EB4535546588042(tmp, il2cpp_codegen_string_new_wrapper("\x48\x6F\x77\x20\x6A\x69\x74\x74\x65\x72\x79\x20\x74\x6F\x20\x6D\x61\x6B\x65\x20\x74\x68\x65\x20\x63\x6F\x72\x6B\x73\x63\x72\x65\x77\x20\x65\x66\x66\x65\x63\x74"), NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkscrewAxis(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_seed(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_xAxisScale(CustomAttributesCache* cache)
{
{
HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB * tmp = (HeaderAttribute_t9B431E6BA0524D46406D9C413D6A71CB5F2DD1AB *)cache->attributes[0];
HeaderAttribute__ctor_m601319E0BCE8C44A9E79B2C0ABAAD0FEF46A9F1E(tmp, il2cpp_codegen_string_new_wrapper("\x4E\x6F\x6E\x2D\x75\x6E\x69\x66\x6F\x72\x6D\x20\x73\x63\x61\x6C\x69\x6E\x67\x20\x28\x73\x65\x74\x20\x74\x6F\x20\x6C\x69\x6E\x65\x61\x72\x20\x66\x6F\x72\x20\x75\x6E\x69\x66\x6F\x72\x6D\x20\x73\x63\x61\x6C\x69\x6E\x67\x29"), NULL);
}
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[1];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_yAxisScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_zAxisScale(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growbies_get_IsDirty_mDA93F1481DFD6E98300EC8FC674563380667DFB0(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growbies_set_IsDirty_m065549E573178808FA04A00AE1F31F618DF1B5AC(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CPrivateImplementationDetailsU3E_t6BC7664D9CD46304D39A7D175BB8FFBE0B9F4528_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
IL2CPP_EXTERN_C const CustomAttributesCacheGenerator g_AssemblyU2DCSharp_AttributeGenerators[];
const CustomAttributesCacheGenerator g_AssemblyU2DCSharp_AttributeGenerators[476] =
{
U3CU3Ec_t43FDE974E52D7C6CDA8B25128E2467049C5C3F2D_CustomAttributesCacheGenerator,
U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_CustomAttributesCacheGenerator,
U3CU3Ec_t49911D0DBBA0A1916E776BDF2D6019A9A05B514B_CustomAttributesCacheGenerator,
U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_CustomAttributesCacheGenerator,
U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_CustomAttributesCacheGenerator,
U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_CustomAttributesCacheGenerator,
U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_CustomAttributesCacheGenerator,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator,
U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_CustomAttributesCacheGenerator,
ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator,
U3CPrivateImplementationDetailsU3E_t6BC7664D9CD46304D39A7D175BB8FFBE0B9F4528_CustomAttributesCacheGenerator,
ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_loadSceneMode,
ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_contentName,
ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_loadOnKeyPress,
ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_keyCode,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipRadius,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatDissipateSpeed,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatGainSpeed,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatRadiusMultiplier,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numWisps,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_seekStrength,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_velocityDampen,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_initialVelocity,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_offsetMultiplier,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_colorCycleSpeed,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_baseWispColor,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_heatWispColor,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipColor,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispMat,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispSize,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_ambientNoise,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_agitatedNoise,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_fingertipVelocityColor,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispAudio,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionAudio,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionVolume,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionPitch,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_wispVolume,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_distortionFadeSpeed,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numTiles,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numColumns,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_numRows,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_tileScale,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_tileOffsets,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_currentTileNum,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_U3CInitializedU3Ek__BackingField,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_U3CSurfacePositionU3Ek__BackingField,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingers,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palms,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_disableInactiveFingersInEditor,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingerRigidBodies,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_fingerColliders,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palmRigidBodies,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_palmColliders,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_surfaceTransform,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_sampler,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_oceanCollider,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_numBoids,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_coherenceAmount,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_alignmentAmount,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_separationAmount,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_fleeAmount,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_maxSpeed,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_maxForce,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_minDistance,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidRespawnTime,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_surfaceBounce,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_surfaceBounceSpeed,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_agitationMultiplier,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_forceRadius,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_splashPrefab,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_bounceCurve,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_flockRotate,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_normalAudio,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_fleeingAudio,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_masterVolume,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_audioChangeSpeed,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_numBoidsFleeingMaxVolume,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidMesh,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidMat,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_boidScale,
Flock_t165C420D4323CDD2A291571E7776D838DC4963AA_CustomAttributesCacheGenerator_positionMap,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_flock,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_asteroids,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_impactPrefab,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_explosionRespawnDelay,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_collisionTimeoutDelay,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_despawnedMaterial,
FlockAsteroids_tA180CDB7882C0C9699DABA48B6192F7AF65C0CB7_CustomAttributesCacheGenerator_despawnedGradient,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_sampler,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_minRadius,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxRadius,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_agitationForce,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_radiusChangeSpeed,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_gravity,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_blendShapeCurves,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopCenter,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerGlowGradient,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerPoppedGradient,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerGlowCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerPoppedCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_centerSquirmCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopBlorbPrefabs,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_bloatGradientEmission,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_bloatGradientColor,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_poppedGradientColor,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_baseGradientColor,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxDistToFinger,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_maxBloatBeforePop,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_respawnTime,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerAgitationCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popRecoveryCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popRecoveryScaleCurve,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_popParticles,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_emissionColorPropName,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTips,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTipSlimeFadeSpeed,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_fingerTipSlimeColor,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopDistance,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_goopSlimes,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_timeLastPopped,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosAudio,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosVolume,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_growthChaosPitch,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_rotationSpeed,
GoopBlorb_t9629F618A80F58AC7278B62806B18766CED5F62E_CustomAttributesCacheGenerator_meshRenderer,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_lineRenderer,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_maxStretch,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_minWidth,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_maxWidth,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_droopSpeedCurve,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_droopCurve,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_widthCurve,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_followCurve,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_origin,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_target,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inertia,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_targetSeekStrength,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inertiaStrength,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_inheritedStrength,
GoopSlime_t3594F47365FC7AC759D5C52B9DDF131787DA2928_CustomAttributesCacheGenerator_gravityStrength,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_growbies,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_fingerInfluence,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonRevertSpeed,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonChangeSpeed,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_seasonTargets,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_mainLightColor,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_overallSeason,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_growbieParticles,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_winterAudio,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_winterAudioCurve,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_summerAudio,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_summerAudioCurve,
GrowbieSphere_tB72A23804D5373339F3765088C11E6C55ED7B04A_CustomAttributesCacheGenerator_masterVolume,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftHandObject,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightHandObject,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftHandRoot,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightHandRoot,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftJointMaps,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightJointMaps,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_leftJointRotOffset,
HandMeshSurface_tC5D2363619A5969E39D8C9A44D392572F91E456B_CustomAttributesCacheGenerator_rightJointRotOffset,
JointMap_tCEC1674D0AC1373CD1630729F0EBE75F01E7E1BF_CustomAttributesCacheGenerator_Transform,
HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJoints,
HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJointRigidBodies,
HandSurface_t72171E13A0450FF56543EEB133611ADF4B984E0B_CustomAttributesCacheGenerator_handJointColliders,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_chunks,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_initialImpulseForce,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingerForceDist,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingerPushForce,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_innerCollider,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatIncreaseSpeed,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatDecreaseSpeed,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_heatColor,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_fingertipHeatColor,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_baseColor,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_minTimeBetweenImpacts,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_impactClips,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_volumeCurve,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_lavaBubbles,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_bubbleDistance,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_spawnOdds,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_bubbleCheckRadius,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_chunkLayer,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_lavaMat,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_scrollSpeed,
Lava_tF6316393678D825EADEC50B5D75853F6860AFC6E_CustomAttributesCacheGenerator_impactParticles,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_U3COnCollisionU3Ek__BackingField,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_U3CSubmergedAmountU3Ek__BackingField,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_gravityTarget,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_particles,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_particlesPrefab,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_lineRenderer,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point1Particles,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point2Particles,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point1,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_point2,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_jitter,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_maxLightIntensity,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_noiseScale,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_noiseSpeed,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_minWidth,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_maxWidth,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_widthCurve,
Arc_t2B4E1B1C88B008A960144A6D0D00F1D7C6126D0F_CustomAttributesCacheGenerator_boltTextures,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_fingerAudio,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_jitterCurve,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_point1Light,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_U3CPoint1SampleIndexU3Ek__BackingField,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_sampler,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_surfaceArcs,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerArcs,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerArcSources,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_randomSurfaceArcChange,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_randomFingerArcChange,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerEngageDistance,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerRandomPosRadius,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_fingerDisengageDistance,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_glowGradient,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_coreRenderer,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_glowSpeed,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_intensityCurve,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_flickerCurve,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_buzzAudioPitch,
Lightning_t6B53C81AC1252F8CE25F605493E192B1D4CC2F39_CustomAttributesCacheGenerator_buzzAudio,
SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_gravityCurve,
SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_gravityResetCurve,
SurfaceArc_tF31396A7883E415ECFC1C8E01ECAD9CD9DB25792_CustomAttributesCacheGenerator_arcEscapeStrength,
LoadFirstScene_tB15D9B41665EB1A9BC1BB9B1A563C5458D6FBE7C_CustomAttributesCacheGenerator_contentName,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_mesh,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_numPointsToSample,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapResX,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapResY,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapUvTest,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_dispMapTriIndexTest,
MeshSampler_t295914DFF5598E80034DCDA62AB2368DAE057DD7_CustomAttributesCacheGenerator_uvChannel,
Tutorial_t00E576E62CB1B76A4CEB914E180C4F6F2CC63BF3_CustomAttributesCacheGenerator_holdUpPalmText,
Tutorial_t00E576E62CB1B76A4CEB914E180C4F6F2CC63BF3_CustomAttributesCacheGenerator_menu,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CChunkImpactIntensityU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CFingerImpactIntensityU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3COnImpactU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastOtherColliderU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastImpactIntensityU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CLastImpactTypeU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_U3CRadiusU3Ek__BackingField,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_impactAudio,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_volumePrefab,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_centralParticles,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0Core,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0Surface,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_coreRadius,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0RadiusMin,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen0RadiusMax,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1Count,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1RadiusMin,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen1RadiusMax,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2Count,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2RadiusMin,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen2RadiusMax,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3Count,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3RadiusMin,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_gen3RadiusMax,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionColor,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_linePrefab,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen1,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen2,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_connectionGradientGen3,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftIntensity,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftScale,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_driftTimeScale,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_seekForce,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactClips,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactClip,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactVolume,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactGradient,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_volumeImpactGradient,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_chunkImpactFadeTime,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_fingerImpactFadeTime,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_baseFingerColor,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_drawConnections,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_minImpactParticleIntensity,
Volume_tFDE94869302B57FFCE74AC2F1C013FC0AE95C9AE_CustomAttributesCacheGenerator_impactParticles,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_audio,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_domeRenderer,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_burstRenderer,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_coneRenderer,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_soundWaveRenderer,
Note_tAD11671700697604C063CE3D92BF2B8EBC5775F7_CustomAttributesCacheGenerator_animator,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notesTransforms,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notes,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_notePrefab,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_noteParent,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_noteData,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedGradient,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedGradient,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedPosCurve,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedPosCurve,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_pressedOffset,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releasedOffset,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_releaseAnimationDuration,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_timeBetweenNoteReleases,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_emissiveColorName,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_emissiveColorNameBurst,
Xylophone_t15D31B5D9D7453A5AD76D4E751286A7C8C226C01_CustomAttributesCacheGenerator_albedorColorName,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_defaultOffset,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_maxRepositionDistance,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_useSpatialUnderstanding,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_moveIncrement,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_timeOut,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_spatialAwarenessMask,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_zOffset,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotate,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scale,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleCurve,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotateSpeed,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleSpeed,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_rotateOffset,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_scaleOffset,
Billboard_tAC69CF54C2D2C8006AAB30B36C97891FB11F0F65_CustomAttributesCacheGenerator_randomScaleOffset,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_fingerForce,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleDriftSpeed,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleReturnSpeed,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleTransform,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubble,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_controller,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_enterBubbleClips,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_touchBubbleCurve,
Bubble_tD9D9B5E0EF32C4BA113EA178A0A32810EC952486_CustomAttributesCacheGenerator_bubbleTouchParticles,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_RadiusMultiplier,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_TurbulenceMultiplier,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_TurbulenceSpeed,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Transparency,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Gaze,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Highlight,
BubbleController_t8253B7CC736DD545ECE98461E827AEA3AFD04A9D_CustomAttributesCacheGenerator_Freeze,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_U3COnEnterBubbleU3Ek__BackingField,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_U3COnExitBubbleU3Ek__BackingField,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radius,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radiusMultiplier,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_useVertexNoise,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_useVertexColors,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_defaultVertexColor,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_meshFilter,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_meshRenderer,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_recursionLevel,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_normalAngle,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceCurve,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceCurve,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceCurve,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceMultiplier,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceMultiplier,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceMultiplier,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_radialForceInertia,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_atomicForceInertia,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbleForceInertia,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceMultiplier,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceSpeed,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_turbulenceScale,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_innerBubbles,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_minInnerBubbleRadius,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_solidity,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_drawForces,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_forceDrawSkipInterval,
BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_drawTrails,
BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailProps,
BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trails,
BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailBubbleInertia,
BubbleTrails_t2E856ABE6A1305972275D648E663D0CDCDD65AA8_CustomAttributesCacheGenerator_trailBubbleForceMultiplier,
ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatInterval,
ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatBlendTime,
ShaderTimeUpdater_tCB7A8603C6CD97D649387059C0322AD0C36DE24F_CustomAttributesCacheGenerator_repeatBlendCurve,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_U3CActivatedOnceU3Ek__BackingField,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_animationTarget,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_openCurve,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_closeCurve,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_disableDistance,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_U3CTargetPositionU3Ek__BackingField,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_U3CExplodedPositionU3Ek__BackingField,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_asteroidRenderer,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLight,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_trailTargetTime,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_rotationSpeed,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLightExplosionColor,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_hoverLightNormalColor,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_growthCurve,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_audioSource,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_impactClip,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_respawnClip,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_impactVolume,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_respawnVolume,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_despawnedMaterial,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_spawnedMaterial,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_neutralParticles,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_winterParticles,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_summerParticles,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_emissionRate,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_neutralEmissionCurve,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_winterEmissionCurve,
GrowbieParticles_t75FB8B250BBDA87A3475D1A4E2666A121B088D4B_CustomAttributesCacheGenerator_summerEmissionCurve,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_Season,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_ChangeSpeed,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_influenceCenter,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterGrowbies,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_neutralGrowbies,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerGrowbies,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterGrowthCurve,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_neutralGrowthCurve,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerGrowthCurve,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_winterClips,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_summerClips,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_audioSource,
GrowbieSeasons_t950534ACFA36C2231F15DB91935EB5064670582F_CustomAttributesCacheGenerator_volumeMultiplier,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_U3CIsDirtyU3Ek__BackingField,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growth,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthRandomness,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthJitter,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_growthScaleMultiplier,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkScrewAmount,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkscrewJitter,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_corkscrewAxis,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_seed,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_xAxisScale,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_yAxisScale,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_zAxisScale,
ButtonLoadContentScene_tB11760A90E304E539FCB6692CE04B04A9DA119E6_CustomAttributesCacheGenerator_ButtonLoadContentScene_U3CLoadContentU3Eb__5_0_m0F2BAB71C442DA2D6DD2175FA2F624413388AEA3,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_Ephemeral_UpdateWispsTask_m6394F82B466F3D9C7A5C8C4B86D557B9A6AE04A3,
Ephemeral_t92AB7EAE5C2E7D8ED914E17A58FB9CC2117255A5_CustomAttributesCacheGenerator_Ephemeral_UpdateWisps_m07B2A1316E992F0C63DE9164CFDE0A991940571C,
U3CUpdateWispsTaskU3Ed__59_tD02A9C79285C9925DF565090B545A7533139D5E3_CustomAttributesCacheGenerator_U3CUpdateWispsTaskU3Ed__59_SetStateMachine_mF28B0A6C88891567ED86C4A0214C1E0B3BE12A30,
U3CUpdateWispsU3Ed__66_t9B924AC665FDA18DB76B472F5FDFF6FD45CF45A9_CustomAttributesCacheGenerator_U3CUpdateWispsU3Ed__66_SetStateMachine_m418F25120B4C81FA7CE82086B2A6CBC48237D287,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_get_Initialized_m8BCDDB4DF79FBFA9051F901D8701830BA8739FA4,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_set_Initialized_m468F44FAA1F96A6E5422A0A8123D4895E4329D4B,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_get_SurfacePosition_mF548C1A7C23931BC08953F30F9227B6265140028,
FingerSurface_t5E68C52AF4D5D94C9B95DCBB8A31672B2E011C21_CustomAttributesCacheGenerator_FingerSurface_set_SurfacePosition_m1ED8F1CEEBA5BC94A4A2AFDEC15789CCC480D5E2,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_Goop_UpdateBlorbsLoop_m986AFC428EF64DB53EC5976F8BF9E8CBBC48E415,
Goop_t8741962FF5D05169A8C0927E6362E6C5B3F05F47_CustomAttributesCacheGenerator_Goop_UpdateBlorbs_mABD7F7D7F1A0B432F4FD89D33896F0AADDE82D0A,
U3CUpdateBlorbsLoopU3Ed__58_t01AD4077C07F2E5FBCD547BCF01C199EA8A6DE62_CustomAttributesCacheGenerator_U3CUpdateBlorbsLoopU3Ed__58_SetStateMachine_m0AD947925371163FB699FEAB47B3860A98A38222,
U3CUpdateBlorbsU3Ed__59_t7C83DFEA42433323662D1E49915D62A60C67D07B_CustomAttributesCacheGenerator_U3CUpdateBlorbsU3Ed__59_SetStateMachine_mC0A06B4D05DD9C12B90C278C353AB2DDC3BEB13A,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_get_OnCollision_mD08DBDB130307B7476EE0048AA1FFA5D09C63E56,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_set_OnCollision_m81FA4F0500DD9C2430CFEF95463FF07F9875F661,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_get_SubmergedAmount_mE70C23EA381F4A29EE98CD18417041DA5691FFFF,
LavaChunk_t7945C6A24CC9DA90E66462FC75209524D94D0759_CustomAttributesCacheGenerator_LavaChunk_set_SubmergedAmount_m3198E1F1B5D613F134A0A1E1326CFAAC9D204A55,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_FingerArc_get_Point1SampleIndex_mD059D02CE72FF48BC3C2CA82E407BA4B6AC86961,
FingerArc_t7D7126A2D8F210911C884E421AB742A5CB025131_CustomAttributesCacheGenerator_FingerArc_set_Point1SampleIndex_mCC2A0AC52480743A3E885AA86B978ADA556ADD15,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_ChunkImpactIntensity_m1807D63C5B630D450B3E2AEA29AEB5A1E8FDACE2,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_ChunkImpactIntensity_m927159F8F8B2FD7FC95FB03F58B8F57921010FAB,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_FingerImpactIntensity_m1CE7563DEEAB831F2C036A4DFFBC11633B9BB7B3,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_FingerImpactIntensity_m220556FA6D06D229B034F68B2989B2334639F973,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_OnImpact_mE14A44BE107C2E33241E312F948D20131BF6C860,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_OnImpact_m6422199BF7D8E1D4E0A54A7FE2AB6D6B5F72385A,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastOtherCollider_m2520C1755860A6DD8492BB447C3BF4C7F9EE75EE,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastOtherCollider_mA41C25E5C29C769AA31E61E6A206C99761FCE55B,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastImpactIntensity_m1DD1F66AB5B866394039424880BD2B378DDC6DDF,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastImpactIntensity_mF69C6DD25806A0693390F08B708922DDE2D81766,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_LastImpactType_m8FC0B9188E2B96205BF90677F63604DE47F79FF7,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_LastImpactType_mB778B2D8B59D0ACD1CF5AA6C22FC0E0ACED9C5E9,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_get_Radius_m5705FDA4CE6B0711DD0DC0CBD6AFC799B1BA2E04,
ChunkImpacts_tB59C9E34B4576CCB866AC2D06CEF3A7DA8D438EE_CustomAttributesCacheGenerator_ChunkImpacts_set_Radius_mD01BBBEB17A03805057D50AB3804A10556E8CF6C,
SurfacePlacement_t35A298C9B4CDA8A63D6B83A1A487896E0501FA65_CustomAttributesCacheGenerator_SurfacePlacement_PlaceNewSurface_m47ED70EFEA4C987DCBC1C592096F26A955649D30,
U3CPlaceNewSurfaceU3Ed__14_t5F8C7ACBE6604140064D6DA6F94C6395BC55B693_CustomAttributesCacheGenerator_U3CPlaceNewSurfaceU3Ed__14_SetStateMachine_m615B0FC5AC8486760391A9390B0CA1950CDBED30,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_get_OnEnterBubble_mEBAAF8051AF84AD702109C8DB043CBC54C631535,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_set_OnEnterBubble_mC594F6A0CED6CE8CDF9ED0D0BDE82DCB89D819D3,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_get_OnExitBubble_m5AB5A4AF0C1CC2CF076F46389E87A9BF08730FEE,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_set_OnExitBubble_mF4AF58A854FA5F7455E5EE4BB8287A38234A9DB2,
BubbleSimple_t3C427985AECCD3D888AA2F905DC5705F3D188FC6_CustomAttributesCacheGenerator_BubbleSimple_UpdateBubbleAsync_mDAAA6DA5F82218CE51E52EFBDF394DA10C479C13,
U3CUpdateBubbleAsyncU3Ed__85_tCAB394B6D7A8ACCB602C35712CB0487CFF941C6B_CustomAttributesCacheGenerator_U3CUpdateBubbleAsyncU3Ed__85_SetStateMachine_m4EC7E00BED36B10F0784AD5438EA19DC94E1E7EB,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_ContextualHandMenu_get_ActivatedOnce_mCDD4C36FFEFB15172240B6C5FD5B6107D9B18268,
ContextualHandMenu_t759A2D8933D90C156119BC05B6F115D426C128F5_CustomAttributesCacheGenerator_ContextualHandMenu_set_ActivatedOnce_m62012EFA052D5827C098DCD179B984C23FA3CB6D,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_get_TargetPosition_m78214B3808F7828BD598FF785EBDD855654E7690,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_set_TargetPosition_m45C00CD43AE53FAFD099F9E6B1CFA1309C2A1571,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_get_ExplodedPosition_m1692B2FBC824BF23849E1556D6C68B94E4B09667,
FlockAsteroid_t6030769D069F2D9FB65348863141CC98A6525F4B_CustomAttributesCacheGenerator_FlockAsteroid_set_ExplodedPosition_m8F5C92828EF2D194FBCC878FD55C700E2E539381,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growbies_get_IsDirty_mDA93F1481DFD6E98300EC8FC674563380667DFB0,
Growbies_tA55C49930F25BC15862295D5DFE1C24FE0A786C8_CustomAttributesCacheGenerator_Growbies_set_IsDirty_m065549E573178808FA04A00AE1F31F618DF1B5AC,
AssemblyU2DCSharp_CustomAttributesCacheGenerator,
};
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, bool ___value0, const RuntimeMethod* method)
{
{
bool L_0 = ___value0;
__this->set_m_wrapNonExceptionThrows_0(L_0);
return;
}
}
| 59.911542 | 381 | 0.896959 | JBrentJ |
a6f14a7d1edc2fc844996ba02934d8967a12f826 | 1,373 | hpp | C++ | threadpool.hpp | wangAlpha/SimpleDB | 0b37bd6a2481b266fc894d82d410759c39d06a72 | [
"MIT"
] | 8 | 2020-03-10T09:19:54.000Z | 2021-12-03T08:51:04.000Z | threadpool.hpp | wangAlpha/SimpleDB | 0b37bd6a2481b266fc894d82d410759c39d06a72 | [
"MIT"
] | null | null | null | threadpool.hpp | wangAlpha/SimpleDB | 0b37bd6a2481b266fc894d82d410759c39d06a72 | [
"MIT"
] | 1 | 2021-12-03T08:51:06.000Z | 2021-12-03T08:51:06.000Z | #pragma once
#include "core.hpp"
// 线程池
class ThreadPool {
public:
explicit ThreadPool(size_t const thread_count)
: data_(std::make_shared<data>()) {
for (size_t i = 0; i < thread_count; ++i) {
std::thread([data = data_] {
std::unique_lock<std::mutex> lock(data->mutex_);
for (;;) {
if (!data->tasks_.empty()) {
auto task = std::move(data->tasks_.front());
data->tasks_.pop();
lock.unlock();
task();
lock.lock();
} else if (data->is_shutdown_) {
break;
} else {
data->cond_.wait(lock);
}
}
})
.detach();
}
}
ThreadPool() = default;
ThreadPool(ThreadPool&&) = default;
~ThreadPool() {
if (bool(data_)) {
{
std::lock_guard<std::mutex> lock(data_->mutex_);
data_->is_shutdown_ = true;
}
data_->cond_.notify_all();
}
}
// 任务提交
template <class Fn>
void execute(Fn&& task) {
{
std::lock_guard<std::mutex> lock(data_->mutex_);
data_->tasks_.emplace(std::forward<Fn>(task));
}
data_->cond_.notify_one();
}
private:
struct data {
std::mutex mutex_;
std::condition_variable cond_;
bool is_shutdown_ = false;
std::queue<std::function<void()> > tasks_;
};
std::shared_ptr<data> data_;
};
| 22.883333 | 56 | 0.529497 | wangAlpha |
a6f595667f3d0b817b0ed6fbeac5e85d69eb8116 | 5,842 | cpp | C++ | Uncategorized/oly19practice31.cpp | crackersamdjam/DMOJ-Solutions | 97992566595e2c7bf41b5da9217d8ef61bdd1d71 | [
"MIT"
] | null | null | null | Uncategorized/oly19practice31.cpp | crackersamdjam/DMOJ-Solutions | 97992566595e2c7bf41b5da9217d8ef61bdd1d71 | [
"MIT"
] | null | null | null | Uncategorized/oly19practice31.cpp | crackersamdjam/DMOJ-Solutions | 97992566595e2c7bf41b5da9217d8ef61bdd1d71 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define gc getchar()
#define pc(x) putchar(x)
template<typename T> void scan(T &x){x = 0;bool _=0;T c=gc;_=c==45;c=_?gc:c;while(c<48||c>57)c=gc;for(;c<48||c>57;c=gc);for(;c>47&&c<58;c=gc)x=(x<<3)+(x<<1)+(c&15);x=_?-x:x;}
template<typename T> void printn(T n){bool _=0;_=n<0;n=_?-n:n;char snum[65];int i=0;do{snum[i++]=n%10+48;n/= 10;}while(n);--i;if (_)pc(45);while(i>=0)pc(snum[i--]);}
template<typename First, typename ... Ints> void scan(First &arg, Ints&... rest){scan(arg);scan(rest...);}
template<typename T> void print(T n){printn(n);pc(10);}
template<typename First, typename ... Ints> void print(First arg, Ints... rest){printn(arg);pc(32);print(rest...);}
using namespace std;
void init(){
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("err.txt", "w", stderr);
#endif
}
const int MM = 3e5+5;
using ll = long long;
using T = ll;
constexpr ll inf = 1e15;
struct node{
T val, lp;
bool up;
void apply(T v){
val += v;
lp += v;
up = 1;
}
};
struct segtree{
#define lc (rt<<1)
#define rc (rt<<1|1)
#define nm ((nl+nr)>>1)
node tree[MM*4];
T DEF = 0;
//default value
T merge(T va, T vb){
return max(va, vb);
}
void push_up(int rt){
tree[rt].val = merge(tree[lc].val, tree[rc].val);
}
// node with lazy val means yet to push to children (but updated itself)
void push_down(int rt, int nl, int nr){
T &val = tree[rt].lp;
if(tree[rt].up && nl != nr){
tree[lc].apply(val);
tree[rc].apply(val);
}
val = DEF;
tree[rt].up = 0;
}
void build(int l = 0, int r = MM-1, int rt = 1){
int nl = l, nr = r;
tree[rt].val = DEF;
tree[rt].lp = 0;
tree[rt].up = 0;
if(l == r){
return;
}
build(l, nm, lc);
build(nm+1, r, rc);
push_up(rt);
}
void update(int l, int r, T val, int nl = 0, int nr = MM-1, int rt = 1){
if(r < nl || l > nr)
return;
if(l <= nl && r >= nr){
if(val == 0){
tree[rt].val = tree[rt].lp = 0;
}
else
tree[rt].apply(val);
return;
}
push_down(rt, nl, nr);
update(l, r, val, nl, nm, lc);
update(l, r, val, nm+1, nr, rc);
push_up(rt);
}
T query(int l, int r, int nl = 0, int nr = MM-1, int rt = 1){
if(r < nl || l > nr)
return -inf;
if(l <= nl && r >= nr)
return tree[rt].val;
push_down(rt, nl, nr);
return merge(query(l, r, nl, nm, lc), query(l, r, nm+1, nr, rc));
}
#undef lc
#undef rc
#undef nm
} t;
struct node2{
T val, lp;
bool up;
void apply(T v){
val += v;
lp += v;
up = 1;
}
};
struct segtree2{
#define lc (rt<<1)
#define rc (rt<<1|1)
#define nm ((nl+nr)>>1)
node2 tree[MM*4];
T DEF = 0;
//default value
T merge(T va, T vb){
return va + vb;
}
void push_up(int rt){
tree[rt].val = merge(tree[lc].val, tree[rc].val);
}
// node with lazy val means yet to push to children (but updated itself)
void push_down(int rt, int nl, int nr){
T &val = tree[rt].lp;
if(tree[rt].up && nl != nr){
tree[lc].apply(val);
tree[rc].apply(val);
}
val = DEF;
tree[rt].up = 0;
}
void build(int l = 0, int r = MM-1, int rt = 1){
int nl = l, nr = r;
tree[rt].val = DEF;
tree[rt].lp = 0;
tree[rt].up = 0;
if(l == r){
return;
}
build(l, nm, lc);
build(nm+1, r, rc);
push_up(rt);
}
void update(int l, int r, T val, int nl = 0, int nr = MM-1, int rt = 1){
if(r < nl || l > nr)
return;
if(l <= nl && r >= nr){
tree[rt].apply(val);
return;
}
push_down(rt, nl, nr);
update(l, r, val, nl, nm, lc);
update(l, r, val, nm+1, nr, rc);
push_up(rt);
}
T query(int l, int r, int nl = 0, int nr = MM-1, int rt = 1){
if(r < nl || l > nr)
return DEF;
if(l <= nl && r >= nr)
return tree[rt].val;
push_down(rt, nl, nr);
return merge(query(l, r, nl, nm, lc), query(l, r, nm+1, nr, rc));
}
#undef lc
#undef rc
#undef nm
} t2;
int hi, lo = 1e9;
int n, a[MM],id[MM], b[MM];
ll cnt, best;
set<pair<int, int>> rm;
int main(){
init();
scan(n);
for(int i = 1; i <= n; i++){
scan(a[i]);
cnt += t2.query(a[i], MM-1);
t2.update(a[i], a[i], 1);
if(a[i] > hi){
hi = a[i];
id[i] = 1;
}
}
for(int i = n; i; i--){
if(a[i] < lo){
lo = a[i];
id[i] = 2;
}
}
t.build();
t.update(0, MM-1, -inf);
int hii = 0;
for(int i = 1; i <= n; i++){
if(!id[i]){
t.update(a[i], hii, 1);
rm.insert({a[i], hii});
}
else if(id[i] == 1){
hii = a[i];
t.update(a[i], a[i], 0);
}
else{
while(rm.size() and rm.begin()->first < a[i]){
t.update(rm.begin()->first, rm.begin()->second, -1);
rm.erase(rm.begin());
}
best = max(best, 2*t.query(a[i], MM-1));
}
}
print(cnt-best);
return 0;
} | 25.290043 | 175 | 0.427422 | crackersamdjam |
a6f905302c83c84fad7f0df79783718e0125ab77 | 4,498 | tpp | C++ | Turtle/src.tpp/Upp_TurtleServer_en-us.tpp | mirek-fidler/Turtle | fd413460c3d92c9a85fc620f6f3db50d96f3be2f | [
"BSD-2-Clause"
] | 2 | 2021-01-07T20:30:16.000Z | 2021-02-11T21:33:07.000Z | Turtle/src.tpp/Upp_TurtleServer_en-us.tpp | mirek-fidler/Turtle | fd413460c3d92c9a85fc620f6f3db50d96f3be2f | [
"BSD-2-Clause"
] | null | null | null | Turtle/src.tpp/Upp_TurtleServer_en-us.tpp | mirek-fidler/Turtle | fd413460c3d92c9a85fc620f6f3db50d96f3be2f | [
"BSD-2-Clause"
] | null | null | null | topic "TurtleServer";
[i448;a25;kKO9;2 $$1,0#37138531426314131252341829483380:class]
[l288;2 $$2,2#27521748481378242620020725143825:desc]
[0 $$3,0#96390100711032703541132217272105:end]
[H6;0 $$4,0#05600065144404261032431302351956:begin]
[i448;a25;kKO9;2 $$5,0#37138531426314131252341829483370:item]
[l288;a4;*@5;1 $$6,6#70004532496200323422659154056402:requirement]
[l288;i1121;b17;O9;~~~.1408;2 $$7,0#10431211400427159095818037425705:param]
[i448;b42;O9;2 $$8,8#61672508125594000341940100500538:tparam]
[b42;2 $$9,9#13035079074754324216151401829390:normal]
[2 $$0,0#00000000000000000000000000000000:Default]
[{_}
[ {{10000@(113.42.0) [s0;%% [*@7;4 TurtleServer]]}}&]
[s2; &]
[s1;:Upp`:`:TurtleServer`:`:class: [@(0.0.255)3 class][3 _][*3 TurtleServer][3 _:_][@(0.0.255)3 p
ublic][3 _][*@3;3 VirtualGui]&]
[s2;#%% This class implements a remote gui virtualization server
for U`+`+ applications. By utilizing the modern web technologies
such as HTML`-5 canvas and websockets, TurtleServer allows U`+`+
gui applications to be accessed remotely via modern web browsers,
or, possibly, via specialized client software that understands
the Turtle wire protocol.&]
[s3;%% &]
[ {{10000F(128)G(128)@1 [s0;%% [* Public Method List]]}}&]
[s3; &]
[s5;:Upp`:`:TurtleServer`:`:Bind`(const Upp`:`:String`&`): [_^Upp`:`:TurtleServer^ Turt
leServer][@(0.0.255) `&]_[* Bind]([@(0.0.255) const]_[_^Upp`:`:String^ String][@(0.0.255) `&
]_[*@3 addr])&]
[s2;%% Sets the server bind address to [%-*@3 addr]. Default is `"0.0.0.0`".
Returns `*this for method chaining.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:Host`(const Upp`:`:String`&`): [_^Upp`:`:TurtleServer^ Turt
leServer][@(0.0.255) `&]_[* Host]([@(0.0.255) const]_[_^Upp`:`:String^ String][@(0.0.255) `&
]_[*@3 host])&]
[s2;%% Sets the host URL to [%-*@3 host]. Default URL is `"localhost`".
Returns `*this for method chaining.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:HtmlPort`(int`): [_^Upp`:`:TurtleServer^ TurtleServer][@(0.0.255) `&
]_[* HtmlPort]([@(0.0.255) int]_[*@3 port])&]
[s2;%% Sets the connection port number for serving the html file.
Default is 8888. Returns `*this for method chaining.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:WsPort`(int`): [_^Upp`:`:TurtleServer^ TurtleServer][@(0.0.255) `&
]_[* WsPort]([@(0.0.255) int]_[*@3 port])&]
[s2;%% Sets the connection port number for websocket connection.
Default is 8887. Returns `*this for method chaining.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:MaxConnections`(int`): [_^Upp`:`:TurtleServer^ TurtleServer
][@(0.0.255) `&]_[* MaxConnections]([@(0.0.255) int]_[*@3 limit])&]
[s2;%% Sets a limit to the maximum number of concurrent client conntections.
Default max. connection limit is 100. Returns `*this for method
chaining.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:DebugMode`(bool`): [@(0.0.255) static]
[@(0.0.255) void]_[* DebugMode]([@(0.0.255) bool]_[*@3 b]_`=_[@(0.0.255) true])&]
[s6;%% POSIX only&]
[s2;%% If true, the server will not spawn child processes (no forking).
Useful for debugging purposes.&]
[s3;%% &]
[ {{10000F(128)G(128)@1 [s0;%% [* Constructor detail]]}}&]
[s3; &]
[s5;:Upp`:`:TurtleServer`:`:TurtleServer`(`): [* TurtleServer]()&]
[s2;%% Default constructor. Initializes the server bind address to
`"0.0.0.0`", the host URL to `"localhost`", and the connection
port number to 8888.&]
[s3; &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:TurtleServer`(const Upp`:`:String`&`,int`): [* TurtleServer
]([@(0.0.255) const]_[_^Upp`:`:String^ String][@(0.0.255) `&]_[*@3 host],
[@(0.0.255) int]_[*@3 port])&]
[s2;%% Constructor overload. Initializes the host URL and the connection
port number to provided values.&]
[s3;%% &]
[s4; &]
[s5;:Upp`:`:TurtleServer`:`:TurtleServer`(const Upp`:`:String`&`,Upp`:`:String`&`,int`): [* T
urtleServer]([@(0.0.255) const]_[_^Upp`:`:String^ String][@(0.0.255) `&]_[*@3 ip],
[_^Upp`:`:String^ String][@(0.0.255) `&]_[*@3 host], [@(0.0.255) int]_[*@3 port])&]
[s2;%% Constructor overload. Initializes the server bind adrress,
the host URL and the connection port number to provided values.&]
[s3;%% &]
[ {{10000F(128)G(128)@1 [s0;%% [* Function List]]}}&]
[s3;%% &]
[s5;:Upp`:`:RunTurtleGui`(Upp`:`:TurtleServer`&`,Upp`:`:Event`<`>`): [@(0.0.255) void]_
[* RunTurtleGui]([_^Upp`:`:TurtleServer^ TurtleServer][@(0.0.255) `&]_[*@3 gui],
[_^Upp`:`:Event^ Event]<>_[*@3 app`_main])&]
[s2;%% Starts the Turtle GUI virtualization server and runs a U`+`+
GUI application over it.&]
[s3;%% &]
[s0;%% ]] | 47.851064 | 97 | 0.644731 | mirek-fidler |
a6fab4381de05117acc1f8055187147dc739c4b2 | 16,310 | cpp | C++ | src/bin2llvmir/analyses/reaching_definitions.cpp | bambooeric/retdec | faa531edfcc2030221856232b30a794f5dbcc503 | [
"MIT",
"Zlib",
"BSD-3-Clause"
] | 1 | 2020-08-29T21:43:47.000Z | 2020-08-29T21:43:47.000Z | src/bin2llvmir/analyses/reaching_definitions.cpp | bambooeric/retdec | faa531edfcc2030221856232b30a794f5dbcc503 | [
"MIT",
"Zlib",
"BSD-3-Clause"
] | null | null | null | src/bin2llvmir/analyses/reaching_definitions.cpp | bambooeric/retdec | faa531edfcc2030221856232b30a794f5dbcc503 | [
"MIT",
"Zlib",
"BSD-3-Clause"
] | null | null | null | /**
* @file src/bin2llvmir/analyses/reaching_definitions.cpp
* @brief Reaching definitions analysis builds UD and DU chains.
* @copyright (c) 2017 Avast Software, licensed under the MIT license
*/
#include <iomanip>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <llvm/ADT/PostOrderIterator.h>
#include <llvm/IR/CFG.h>
#include <llvm/IR/Instruction.h>
#include <llvm/IR/Instructions.h>
#include <llvm/Support/raw_ostream.h>
#include "retdec/utils/time.h"
#include "retdec/bin2llvmir/analyses/reaching_definitions.h"
#include "retdec/bin2llvmir/providers/asm_instruction.h"
#include "retdec/bin2llvmir/providers/names.h"
#define debug_enabled false
#include "retdec/bin2llvmir/utils/llvm.h"
using namespace retdec::utils;
using namespace llvm;
namespace retdec {
namespace bin2llvmir {
//
//=============================================================================
// ReachingDefinitionsAnalysis
//=============================================================================
//
bool ReachingDefinitionsAnalysis::runOnModule(
Module& M,
Abi* abi,
bool trackFlagRegs)
{
_trackFlagRegs = trackFlagRegs;
_abi = abi;
_specialGlobal = AsmInstruction::getLlvmToAsmGlobalVariable(&M);
clear();
initializeBasicBlocks(M);
run();
_run = true;
return false;
}
bool ReachingDefinitionsAnalysis::runOnFunction(
llvm::Function& F,
Abi* abi,
bool trackFlagRegs)
{
_trackFlagRegs = trackFlagRegs;
_abi = abi;
_specialGlobal = AsmInstruction::getLlvmToAsmGlobalVariable(F.getParent());
clear();
initializeBasicBlocks(F);
run();
_run = true;
return false;
}
void ReachingDefinitionsAnalysis::run()
{
initializeBasicBlocksPrev();
initializeKillGenSets();
propagate();
initializeDefsAndUses();
LOG << *this << "\n";
clearInternal();
}
void ReachingDefinitionsAnalysis::initializeBasicBlocks(llvm::Module& M)
{
for (Function& F : M)
{
initializeBasicBlocks(F);
}
}
void ReachingDefinitionsAnalysis::initializeBasicBlocks(llvm::Function& F)
{
for (BasicBlock& B : F)
{
BasicBlockEntry bbe(&B);
int insnPos = -1;
for (Instruction& I : B)
{
++insnPos;
if (auto* l = dyn_cast<LoadInst>(&I))
{
if (!isa<GlobalVariable>(l->getPointerOperand())
&& !isa<AllocaInst>(l->getPointerOperand()))
{
continue;
}
if (!_trackFlagRegs
&& _abi
&& _abi->isFlagRegister(l->getPointerOperand()))
{
continue;
}
bbe.uses.push_back(Use(l, l->getPointerOperand(), insnPos));
}
else if (auto* p2i = dyn_cast<PtrToIntInst>(&I))
{
if (!isa<GlobalVariable>(p2i->getPointerOperand())
&& !isa<AllocaInst>(p2i->getPointerOperand()))
{
continue;
}
if (!_trackFlagRegs
&& _abi
&& _abi->isFlagRegister(p2i->getPointerOperand()))
{
continue;
}
bbe.uses.push_back(Use(p2i, p2i->getPointerOperand(), insnPos));
}
else if (auto* gep = dyn_cast<GetElementPtrInst>(&I))
{
if (!isa<GlobalVariable>(gep->getPointerOperand())
&& !isa<AllocaInst>(gep->getPointerOperand()))
{
continue;
}
if (!_trackFlagRegs
&& _abi
&& _abi->isFlagRegister(gep->getPointerOperand()))
{
continue;
}
bbe.uses.push_back(Use(gep, gep->getPointerOperand(), insnPos));
}
else if (auto* s = dyn_cast<StoreInst>(&I))
{
if (!isa<GlobalVariable>(s->getPointerOperand())
&& !isa<AllocaInst>(s->getPointerOperand()))
{
continue;
}
if (!_trackFlagRegs
&& _abi
&& _abi->isFlagRegister(s->getPointerOperand()))
{
continue;
}
if (I.getOperand(1) == _specialGlobal)
{
continue;
}
bbe.defs.push_back(Definition(s, s->getPointerOperand(), insnPos));
}
else if (auto* a = dyn_cast<AllocaInst>(&I))
{
bbe.defs.push_back(Definition(a, a, insnPos));
}
else if (auto* call = dyn_cast<CallInst>(&I))
{
unsigned args = call->getNumArgOperands();
for (unsigned i=0; i<args; ++i)
{
Value *a = call->getArgOperand(i);
if (!_trackFlagRegs
&& _abi
&& _abi->isFlagRegister(a))
{
continue;
}
if (isa<AllocaInst>(a) || isa<GlobalVariable>(a))
{
bbe.uses.push_back(Use(call, a, insnPos));
}
}
// TODO - can allocated object be read in function call?
// is this ok?
}
else
{
// Maybe, there are other users or definitions.
}
}
bbMap[&F][&B] = bbe;
}
}
void ReachingDefinitionsAnalysis::clear()
{
bbMap.clear();
_run = false;
}
bool ReachingDefinitionsAnalysis::wasRun() const
{
return _run;
}
/**
* Clear internal structures used to compute RDA, but not needed to use it once
* it is computed.
*/
void ReachingDefinitionsAnalysis::clearInternal()
{
for (auto& pair1 : bbMap)
for (auto& pair : pair1.second)
{
BasicBlockEntry& bb = pair.second;
bb.defsOut.clear();
bb.genDefs.clear();
bb.killDefs.clear();
}
}
void ReachingDefinitionsAnalysis::initializeBasicBlocksPrev()
{
for (auto &pair1 : bbMap)
for (auto& pair : pair1.second)
{
auto B = pair.first;
auto &entry = pair.second;
for (auto PI = pred_begin(B), E = pred_end(B); PI != E; ++PI)
{
auto* pred = *PI;
auto p = pair1.second.find(pred);
assert(p != pair1.second.end() && "we should have all BBs stored in bbMap");
entry.prevBBs.insert( &p->second );
}
}
}
void ReachingDefinitionsAnalysis::initializeKillGenSets()
{
for (auto &pair1 : bbMap)
for (auto& pair : pair1.second)
{
pair.second.initializeKillDefSets();
}
}
void ReachingDefinitionsAnalysis::propagate()
{
for (auto &pair1 : bbMap)
{
const Function* fnc = pair1.first;
std::vector<BasicBlockEntry*> workList;
workList.reserve(pair1.second.size());
ReversePostOrderTraversal<const Function*> RPOT(fnc); // Expensive to create
for (auto I = RPOT.begin(); I != RPOT.end(); ++I)
{
const BasicBlock* bb = *I;
auto fIt = pair1.second.find(bb);
assert(fIt != pair1.second.end());
workList.push_back(&(fIt->second));
fIt->second.changed = true;
}
bool changed = true;
while (changed)
{
changed = false;
for (auto* bbe : workList)
{
changed |= bbe->initDefsOut();
}
}
}
}
void ReachingDefinitionsAnalysis::initializeDefsAndUses()
{
for (auto &pair1 : bbMap)
for (auto& pair : pair1.second)
{
BasicBlockEntry &bb = pair.second;
for (Use &u : bb.uses)
{
for (auto dIt = bb.defs.rbegin(); dIt != bb.defs.rend(); ++dIt)
{
Definition &d = *dIt;
if (d.getSource() != u.src)
{
continue;
}
if (d.dominates(&u))
{
d.uses.insert(&u);
u.defs.insert(&d);
break;
}
}
if (u.defs.empty())
{
for (auto p : bb.prevBBs)
for (auto d : p->defsOut)
{
if (d->getSource() == u.src)
{
d->uses.insert(&u);
u.defs.insert(d);
}
}
}
}
}
}
const BasicBlockEntry& ReachingDefinitionsAnalysis::getBasicBlockEntry(
const Instruction* I) const
{
auto* F = I->getFunction();
auto pair1 = bbMap.find(F);
assert(pair1 != bbMap.end() && "we do not have this function in bbMap");
auto* BB = I->getParent();
auto pair = pair1->second.find(BB);
assert(pair != pair1->second.end() && "we do not have this basic block in bbMap");
return pair->second;
}
const DefSet& ReachingDefinitionsAnalysis::defsFromUse(const Instruction* I) const
{
return getBasicBlockEntry(I).defsFromUse(I);
}
const UseSet& ReachingDefinitionsAnalysis::usesFromDef(const Instruction* I) const
{
return getBasicBlockEntry(I).usesFromDef(I);
}
const Definition* ReachingDefinitionsAnalysis::getDef(const Instruction* I) const
{
return getBasicBlockEntry(I).getDef(I);
}
const Use* ReachingDefinitionsAnalysis::getUse(const Instruction* I) const
{
return getBasicBlockEntry(I).getUse(I);
}
std::ostream& operator<<(std::ostream& out, const ReachingDefinitionsAnalysis& rda)
{
for (auto &pair1 : rda.bbMap)
for (auto& pair : pair1.second)
{
out << pair.second;
}
return out;
}
//
//=============================================================================
// BasicBlockEntry
//=============================================================================
//
int BasicBlockEntry::newUID = 0;
BasicBlockEntry::BasicBlockEntry(const llvm::BasicBlock* b) :
bb(b),
id(newUID++)
{
}
void BasicBlockEntry::initializeKillDefSets()
{
killDefs.clear();
genDefs.clear();
for (auto dIt = defs.rbegin(); dIt != defs.rend(); ++dIt)
{
Definition& d = *dIt;
bool added = (killDefs.insert(d.getSource())).second;
if (added)
{
genDefs.insert(&d);
}
}
}
/**
* REACH_in[B] = Sum (p in pred[B]) (REACH_out[p])
* REACH_out[B] = GEN[B] + ( REACH_in[B] - KILL[B] )
*/
Changed BasicBlockEntry::initDefsOut()
{
auto oldSz = defsOut.size();
if (defsOut.empty() && !genDefs.empty())
{
defsOut = std::move(genDefs);
}
for (auto* p : prevBBs)
{
if (p->changed)
{
for (auto* d : p->defsOut)
{
if (killDefs.find(d->getSource()) == killDefs.end())
{
defsOut.insert(d);
}
}
}
}
changed = oldSz != defsOut.size();
return changed;
}
std::string BasicBlockEntry::getName() const
{
std::stringstream out;
std::string name = bb->getName().str();
if (name.empty())
out << names::generatedBasicBlockPrefix << id;
else
out << name;
return out.str();
}
const DefSet& BasicBlockEntry::defsFromUse(const Instruction* I) const
{
static DefSet emptyDefSet;
auto* u = getUse(I);
return u ? u->defs : emptyDefSet;
}
const UseSet& BasicBlockEntry::usesFromDef(const Instruction* I) const
{
static UseSet emptyUseSet;
auto* d = getDef(I);
return d ? d->uses : emptyUseSet;
}
const Definition* BasicBlockEntry::getDef(const Instruction* I) const
{
auto dIt = find(
defs.begin(),
defs.end(),
Definition(const_cast<Instruction*>(I), nullptr, 0));
return dIt != defs.end() ? &(*dIt) : nullptr;
}
const Use* BasicBlockEntry::getUse(const Instruction* I) const
{
auto uIt = find(
uses.begin(),
uses.end(),
Use(const_cast<Instruction*>(I), nullptr, 0));
return uIt != uses.end() ? &(*uIt) : nullptr;
}
std::ostream& operator<<(std::ostream& out, const BasicBlockEntry& bbe)
{
out << "Basic Block = " << bbe.getName() << "\n";
out << "\n\tPrev:\n";
for (auto prev : bbe.prevBBs)
{
out << "\t\t" << prev->getName() << "\n";
}
out << "\n\tDef:\n";
for (auto d : bbe.defs)
{
out << "\t\t" << llvmObjToString(d.def) << "\n";
for (auto u : d.uses)
out << "\t\t\t" << llvmObjToString(u->use) << "\n";
}
out << "\n\tUses:\n";
for (auto u : bbe.uses)
{
out << "\t\t" << llvmObjToString(u.use) << "\n";
for (auto d : u.defs)
out << "\t\t\t" << llvmObjToString(d->def) << "\n";
}
out << "\n";
return out;
}
//
//=============================================================================
// Definition
//=============================================================================
//
Definition::Definition(llvm::Instruction* d, llvm::Value* s, unsigned bbPos) :
def(d),
src(s),
posInBb(bbPos)
{
}
bool Definition::operator==(const Definition& o) const
{
return def == o.def;
}
llvm::Value* Definition::getSource()
{
return src;
}
/**
* Convenience method so that we don't have to check integer positions.
* However, this does not check that the given @a use is indeed an use of this
* definition - users of this method must make sure that it is.
*/
bool Definition::dominates(const Use* use) const
{
return def->getParent() == use->use->getParent() && posInBb < use->posInBb;
}
//
//=============================================================================
// Use
//=============================================================================
//
Use::Use(llvm::Instruction* u, llvm::Value* s, unsigned bbPos) :
use(u),
src(s),
posInBb(bbPos)
{
}
bool Use::operator==(const Use& o) const
{
return use == o.use;
}
bool Use::isUndef() const
{
for (auto* d : defs)
{
if (isa<AllocaInst>(d->def) || isa<GlobalVariable>(d->def))
{
return true;
}
}
return false;
}
//
//=============================================================================
// On-demand methods.
//=============================================================================
//
/**
* Find the last definition of value \p v in basic block \p bb.
* If \p start is defined (not \c nullptr), start the reverse iteration search
* from this instruction, otherwise start from the basic block's back.
* \return Instruction defining \p v (at most one definition is possible in BB),
* or \c nullptr if definition not found.
*/
llvm::Instruction* defInBasicBlock(
llvm::Value* v,
llvm::BasicBlock* bb,
llvm::Instruction* start = nullptr)
{
auto* prev = start;
if (prev == nullptr && !bb->empty())
{
prev = &bb->back();
}
while (prev)
{
if (auto* s = dyn_cast<StoreInst>(prev))
{
if (s->getPointerOperand() == v)
{
return s;
}
}
else if (prev == v) // AllocaInst
{
return prev;
}
prev = prev->getPrevNode();
}
return nullptr;
}
/**
* Find all uses of value \p v in basic block \p bb and add them to \p uses.
* If \p start is defined (not \c nullptr), start the iteration search from
* this instruction, otherwise start from the basic block's front.
* \return \c True if the basic block kills the value, \p false otherwise.
*/
bool usesInBasicBlock(
llvm::Value* v,
llvm::BasicBlock* bb,
std::set<llvm::Instruction*>& uses,
llvm::Instruction* start = nullptr)
{
auto* next = start;
if (next == nullptr && !bb->empty())
{
next = &bb->front();
}
while (next)
{
if (auto* s = dyn_cast<StoreInst>(next))
{
if (s->getPointerOperand() == v)
{
return true;
}
}
for (auto& op : next->operands())
{
if (op == v)
{
uses.insert(next);
}
}
next = next->getNextNode();
}
return false;
}
std::set<llvm::Instruction*> ReachingDefinitionsAnalysis::defsFromUse_onDemand(
llvm::Instruction* I)
{
std::set<llvm::Instruction*> ret;
auto* l = dyn_cast<LoadInst>(I);
if (l == nullptr)
{
return ret;
}
if (!isa<GlobalVariable>(l->getPointerOperand())
&& !isa<AllocaInst>(l->getPointerOperand()))
{
return ret;
}
// Try to find in the same basic block.
//
if (auto* d = defInBasicBlock(l->getPointerOperand(), l->getParent(), l))
{
ret.insert(d);
return ret;
}
std::set<llvm::BasicBlock*> searchedBbs;
std::vector<llvm::BasicBlock*> worklistBbs;
auto preds = predecessors(l->getParent());
std::copy(preds.begin(), preds.end(), std::back_inserter(worklistBbs));
// Try to find in all predecessing basic blocks.
//
while (!worklistBbs.empty())
{
auto* bb = worklistBbs.back();
worklistBbs.pop_back();
searchedBbs.insert(bb);
if (auto* d = defInBasicBlock(l->getPointerOperand(), bb))
{
ret.insert(d);
// Definition found -> predecessors not added.
}
else
{
// No definition found -> add predecessors.
for (auto* p : predecessors(bb))
{
if (searchedBbs.count(p) == 0)
{
worklistBbs.push_back(p);
}
}
}
}
return ret;
}
std::set<llvm::Instruction*> ReachingDefinitionsAnalysis::usesFromDef_onDemand(
llvm::Instruction* I)
{
std::set<llvm::Instruction*> ret;
Value* val = nullptr;
if (auto* s = dyn_cast<StoreInst>(I))
{
val = s->getPointerOperand();
}
else if (auto* a = dyn_cast<AllocaInst>(I))
{
val = a;
}
if (val == nullptr || !(isa<GlobalVariable>(val) || isa<AllocaInst>(val)))
{
return ret;
}
// Try to find in the same basic block.
//
if (usesInBasicBlock(val, I->getParent(), ret, I->getNextNode()))
{
return ret;
}
std::set<llvm::BasicBlock*> searchedBbs;
std::vector<llvm::BasicBlock*> worklistBbs;
auto succs = successors(I->getParent());
std::copy(succs.begin(), succs.end(), std::back_inserter(worklistBbs));
// Try to find in all predecessing basic blocks.
//
while (!worklistBbs.empty())
{
auto* bb = worklistBbs.back();
worklistBbs.pop_back();
searchedBbs.insert(bb);
if (usesInBasicBlock(val, bb, ret))
{
// BB kills value -> successors not added.
}
else
{
// BB does not kill value -> add successors.
for (auto* p : successors(bb))
{
if (searchedBbs.count(p) == 0)
{
worklistBbs.push_back(p);
}
}
}
}
return ret;
}
} // namespace bin2llvmir
} // namespace retdec
| 20.593434 | 83 | 0.605886 | bambooeric |
4700e412fc67c47b1dddda0183a03d6f35c0a14d | 1,730 | cpp | C++ | leetcode/problems/easy/1886-determine-whether-matrix-can-be-obtained-by-rotation.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | 18 | 2020-08-27T05:27:50.000Z | 2022-03-08T02:56:48.000Z | leetcode/problems/easy/1886-determine-whether-matrix-can-be-obtained-by-rotation.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | null | null | null | leetcode/problems/easy/1886-determine-whether-matrix-can-be-obtained-by-rotation.cpp | wingkwong/competitive-programming | e8bf7aa32e87b3a020b63acac20e740728764649 | [
"MIT"
] | 1 | 2020-10-13T05:23:58.000Z | 2020-10-13T05:23:58.000Z | /*
Determine Whether Matrix Can Be Obtained By Rotation
https://leetcode.com/problems/determine-whether-matrix-can-be-obtained-by-rotation/
Given two n x n binary matrices mat and target, return true if it is possible to make mat equal to target by rotating mat in 90-degree increments, or false otherwise.
Example 1:
Input: mat = [[0,1],[1,0]], target = [[1,0],[0,1]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise to make mat equal target.
Example 2:
Input: mat = [[0,1],[1,1]], target = [[1,0],[0,1]]
Output: false
Explanation: It is impossible to make mat equal to target by rotating mat.
Example 3:
Input: mat = [[0,0,0],[0,1,0],[1,1,1]], target = [[1,1,1],[0,1,0],[0,0,0]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise two times to make mat equal target.
Constraints:
n == mat.length == target.length
n == mat[i].length == target[i].length
1 <= n <= 10
mat[i][j] and target[i][j] are either 0 or 1.
*/
class Solution {
public:
vector<vector<int>> rotate(vector<vector<int>>& mat) {
int n = mat.size();
for(int i = 0; i < n / 2; i++) {
for(int j = i; j < n - i - 1; j++) {
int x = mat[i][j];
mat[i][j] = mat[j][n - 1 - i];
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j];
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i];
mat[n - 1 - j][i] = x;
}
}
return mat;
}
bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {
for(int i = 0; i < 4; i++) {
vector<vector<int>> rotated_mat = rotate(mat);
if(rotated_mat == target) return true;
}
return false;
}
}; | 28.833333 | 166 | 0.558382 | wingkwong |
47017aa7672e04bfe6042463eb8d3c51ccec6ced | 2,340 | cpp | C++ | topcoder/srm/src/SRM648/AB.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | null | null | null | topcoder/srm/src/SRM648/AB.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | 19 | 2016-05-04T02:46:31.000Z | 2021-11-27T06:18:33.000Z | topcoder/srm/src/SRM648/AB.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | null | null | null | #include <bits/stdc++.h>
#define each(i, c) for (auto& i : c)
#define unless(cond) if (!(cond))
using namespace std;
typedef long long int lli;
typedef unsigned long long ull;
typedef complex<double> point;
int f(string s)
{
int sum = 0;
for (int i = 0; i < s.size(); ++i) {
for (int j = i + 1; j < s.size(); ++j) {
sum += (s[i] == 'A' && s[j] == 'B');
}
}
return sum;
}
string bt(string s, int idx, const int K)
{
if (idx == s.size()) {
return f(s) == K ? s : "";
}
string t = s;
t[idx] = 'A';
int m = f(t);
if (m == K) return t;
return m <= K ? bt(t, idx + 1, K) : bt(s, idx + 1, K);
}
class AB {
public:
string createString(int N, int K)
{
string t = bt(string(N, 'B'), 0, K);
return f(t) == K ? t : "";
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arg0 = 3; int Arg1 = 2; string Arg2 = "ABB"; verify_case(0, Arg2, createString(Arg0, Arg1)); }
void test_case_1() { int Arg0 = 2; int Arg1 = 0; string Arg2 = "BA"; verify_case(1, Arg2, createString(Arg0, Arg1)); }
void test_case_2() { int Arg0 = 5; int Arg1 = 8; string Arg2 = ""; verify_case(2, Arg2, createString(Arg0, Arg1)); }
void test_case_3() { int Arg0 = 10; int Arg1 = 12; string Arg2 = "BAABBABAAB"; verify_case(3, Arg2, createString(Arg0, Arg1)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main() {
AB ___test;
___test.run_test(-1);
for (int i = 1; i <= 50; ++i) {
cout << i << endl;
for (int j = 0; j <= 50; ++j) {
cout << j << ' ' << ___test.createString(i, j) << endl;
}
}
}
// END CUT HERE
| 32.054795 | 314 | 0.550427 | Johniel |
47058bc83455519ef6323b4814db9f122db3c7ac | 1,335 | hpp | C++ | Server/include/ServerOwner.hpp | arokasprz100/Proxy_server | 5393613dd2b744814d1151d2aee93767d67646bd | [
"MIT"
] | 3 | 2020-05-18T02:05:34.000Z | 2020-05-18T04:42:46.000Z | Server/include/ServerOwner.hpp | arokasprz100/Proxy_server | 5393613dd2b744814d1151d2aee93767d67646bd | [
"MIT"
] | null | null | null | Server/include/ServerOwner.hpp | arokasprz100/Proxy_server | 5393613dd2b744814d1151d2aee93767d67646bd | [
"MIT"
] | 1 | 2019-06-08T17:07:58.000Z | 2019-06-08T17:07:58.000Z | /**
* @file ServerOwner.hpp
* @brief This file contains the definition of functions responsible for launching, stopping as well as handling of signals in this program.
*/
#ifndef ServerOwner_hpp
#define ServerOwner_hpp
#include "Server.hpp"
#include "ClientConnectionType.hpp"
#include "ServerSettings/ServerSettings.hpp"
#include <signal.h>
/**
* @class ServerOwner
*/
class ServerOwner final
{
public:
/**
* This member function starts the server in a way given by arguments.
* @praram port This is the number of a port the server will be listening on.
* @param clientConnectionType This value describes the kind of connections the server will be accepting.
* @see ClientConnectionType
* @param serverSettings This object contains the necessary information read from the json settings file.
* @see ServerSettings
*/
static void startServer(int port, ClientConnectionType clientConnectionType, const ServerSettings& serverSettings);
/**
* This member function stops the server and performs memory cleanup.
*/
static void stopServer();
private:
static Server* server;
};
/**
* @fn This function implements the handling of signal passed as arguemnt.
* @param sig_num Numerical value describing the signal.
*/
void sigintHandler(int sig_num);
#endif // ServerOwner_hpp | 28.404255 | 140 | 0.745318 | arokasprz100 |
4707e2afe1cc405c8596ef711d31ec93dfcae69f | 549 | hh | C++ | src/nn/src/include/dataset.hh | juliia5m/knu_voice | 1f5d150ded23af4c152b8d20f1ab4ecec77b40e1 | [
"Apache-2.0"
] | 717 | 2015-01-03T15:25:46.000Z | 2022-03-30T12:45:45.000Z | src/nn/src/include/dataset.hh | juliia5m/knu_voice | 1f5d150ded23af4c152b8d20f1ab4ecec77b40e1 | [
"Apache-2.0"
] | 91 | 2015-03-19T09:25:23.000Z | 2021-05-19T08:51:26.000Z | src/nn/src/include/dataset.hh | juliia5m/knu_voice | 1f5d150ded23af4c152b8d20f1ab4ecec77b40e1 | [
"Apache-2.0"
] | 315 | 2015-01-21T00:06:00.000Z | 2022-03-29T08:13:36.000Z | /*
* $File: dataset.hh
* $Date: Sun Sep 08 08:47:09 2013 +0800
* $Author: Xinyu Zhou <zxytim[at]gmail[dot]com>
*/
#pragma once
#include "type.hh"
#include <vector>
typedef std::vector<std::pair<int, real_t> > Instance;
typedef std::vector<Instance> Dataset;
typedef std::vector<Instance *> RefDataset;
typedef std::vector<const Instance *> ConstRefDataset;
typedef std::vector<int> Labels;
typedef std::vector<real_t> RealLabels;
typedef std::vector<real_t> Vector;
/**
* vim: syntax=cpp11 foldmethod=marker
*/
| 21.115385 | 56 | 0.679417 | juliia5m |
470b9a04555479a3863c18af99b1010e5cd5b023 | 4,643 | cpp | C++ | uwsim_resources/uwsim_osgocean/src/osgOcean/WaterTrochoids.cpp | epsilonorion/usv_lsa_sim_copy | d189f172dc1d265b7688c7dc8375a65ac4a9c048 | [
"Apache-2.0"
] | 1 | 2020-11-30T09:55:33.000Z | 2020-11-30T09:55:33.000Z | uwsim_resources/uwsim_osgocean/src/osgOcean/WaterTrochoids.cpp | epsilonorion/usv_lsa_sim_copy | d189f172dc1d265b7688c7dc8375a65ac4a9c048 | [
"Apache-2.0"
] | null | null | null | uwsim_resources/uwsim_osgocean/src/osgOcean/WaterTrochoids.cpp | epsilonorion/usv_lsa_sim_copy | d189f172dc1d265b7688c7dc8375a65ac4a9c048 | [
"Apache-2.0"
] | 2 | 2020-11-21T19:50:54.000Z | 2020-12-27T09:35:29.000Z | /*
* This source file is part of the osgOcean library
*
* Copyright (C) 2009 Kim Bale
* Copyright (C) 2009 The University of Hull, UK
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free Software
* Foundation; either version 3 of the License, or (at your option) any later
* version.
* 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 Lesser General Public License for more details.
* http://www.gnu.org/copyleft/lesser.txt.
*/
#include <osgOcean/WaterTrochoids>
using namespace osgOcean;
WaterTrochoids::WaterTrochoids(void)
:_amplitude (0.1f)
,_amplitudeMul (0.5f)
,_lambda0 (14.0f)
,_lambdaMul (1.2f)
,_direction (1.00f)
,_angleDev (0.2f)
{
}
WaterTrochoids::WaterTrochoids( float amplitude,
float amplitudeMul,
float baseWavelen,
float wavelenMul,
float direction,
float angleDev )
:_amplitude (amplitude)
,_amplitudeMul (amplitudeMul)
,_lambda0 (baseWavelen)
,_lambdaMul (wavelenMul)
,_direction (direction)
,_angleDev (angleDev)
{
}
WaterTrochoids::WaterTrochoids( const WaterTrochoids& copy )
:_amplitude (copy._amplitude)
,_amplitudeMul (copy._amplitudeMul)
,_lambda0 (copy._lambda0)
,_lambdaMul (copy._lambdaMul)
,_direction (copy._direction)
,_angleDev (copy._angleDev)
,_waves (copy._waves)
{
}
WaterTrochoids::~WaterTrochoids(void)
{
}
void WaterTrochoids::updateWaves(float time)
{
for (std::vector<Wave>::iterator wave = _waves.begin();
wave != _waves.end();
++wave )
{
wave->phase = wave->w*time+wave->phi0;
}
}
void WaterTrochoids::createWaves(void)
{
const float wavesDirX = cos(_direction);
const float wavesDirY = sin(_direction);
_waves.resize(NUM_WAVES);
float A = 1.0f;
float lambda = _lambda0;
for (int i = 0; i < NUM_WAVES; i++)
{
// Randomly rotate the wave around a main direction
float rads = _angleDev * nextRandomDouble(-1,1);
float rx = cos(rads);
float ry = sin(rads);
// Initialize wave vector
float k = 2.f*osg::PI/lambda;
_waves[i].kx = k*(wavesDirX * rx + wavesDirY * ry);
_waves[i].ky = k*(wavesDirX * -ry + wavesDirY * rx);
_waves[i].kmod = k;
// Initialize the wave amplitude
_waves[i].A = A*_amplitude;
_waves[i].Ainvk = _waves[i].A/_waves[i].kmod;
// Initialize the wave frequency, using a standard formula
_waves[i].w = sqrt(9.8f*k);
// Initialize the wave initial phase
_waves[i].phi0 = nextRandomDouble(0, osg::PI*2.f);
// Move to next wave
lambda *= _lambdaMul;
A *= _amplitudeMul;
}
}
void WaterTrochoids::packWaves(osg::FloatArray* constants) const
{
constants->resize( _waves.size() * 5);
unsigned int ptr = 0;
unsigned int itr = _waves.size()/4;
for(unsigned i = 0, j = 0; i < itr; i++, j += 4)
{
// kx
(*constants)[ptr+0] = _waves[j+0].kx;
(*constants)[ptr+1] = _waves[j+1].kx;
(*constants)[ptr+2] = _waves[j+2].kx;
(*constants)[ptr+3] = _waves[j+3].kx;
ptr += 4;
// ky
(*constants)[ptr+0] = _waves[j+0].ky;
(*constants)[ptr+1] = _waves[j+1].ky;
(*constants)[ptr+2] = _waves[j+2].ky;
(*constants)[ptr+3] = _waves[j+3].ky;
ptr += 4;
// amplitude / k
(*constants)[ptr+0] = _waves[j+0].Ainvk;
(*constants)[ptr+1] = _waves[j+1].Ainvk;
(*constants)[ptr+2] = _waves[j+2].Ainvk;
(*constants)[ptr+3] = _waves[j+3].Ainvk;
ptr += 4;
// amplitude
(*constants)[ptr+0] = _waves[j+0].A;
(*constants)[ptr+1] = _waves[j+1].A;
(*constants)[ptr+2] = _waves[j+2].A;
(*constants)[ptr+3] = _waves[j+3].A;
ptr += 4;
// phase
(*constants)[ptr+0] = _waves[j+0].phase;
(*constants)[ptr+1] = _waves[j+1].phase;
(*constants)[ptr+2] = _waves[j+2].phase;
(*constants)[ptr+3] = _waves[j+3].phase;
ptr += 4;
}
}
| 30.546053 | 88 | 0.556752 | epsilonorion |
470bc8fa13523b710f85f15f6066282fa08b5b52 | 11,105 | cpp | C++ | test/audioplayertest.cpp | p-edelman/Transcribe | efa36298c48522d2fc25db4f26ae192fdbef1e23 | [
"Apache-2.0"
] | 2 | 2017-07-28T17:08:57.000Z | 2017-12-16T10:09:30.000Z | test/audioplayertest.cpp | p-edelman/Transcribe | efa36298c48522d2fc25db4f26ae192fdbef1e23 | [
"Apache-2.0"
] | 1 | 2017-08-19T10:42:08.000Z | 2017-10-08T14:46:34.000Z | test/audioplayertest.cpp | p-edelman/Transcribe | efa36298c48522d2fc25db4f26ae192fdbef1e23 | [
"Apache-2.0"
] | null | null | null | #include "audioplayertest.h"
AudioPlayerTest::AudioPlayerTest() {
m_noise_file = QString(SRCDIR);
m_noise_file += "files/noise.wav";
m_silence_file = QString(SRCDIR);
m_silence_file += "files/silence.wav";
m_player = new AudioPlayer();
m_player->openFile(m_noise_file);
}
void AudioPlayerTest::init() {
// Stop the audio playback
m_player->togglePlayPause(false);
// Reset the audio position to start of stream
m_player->setPosition(0);
}
/** Test the initialization of the AudioPlayer. */
void AudioPlayerTest::initAudioPlayer() {
AudioPlayer player;
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE((int)player.getDuration(), 0);
QCOMPARE((int)player.getPosition(), 0);
QCOMPARE(player.getFilePath(), QString(""));
}
/** Test loading of a simple wav file. This should result in the raising of one
* or more durationChanged() signals and a positive result from getDuration().
*/
void AudioPlayerTest::loadFile() {
AudioPlayer player;
QSignalSpy duration_spy(&player, SIGNAL(durationChanged()));
QSignalSpy error_spy(&player, SIGNAL(error(const QString&)));
player.openFile(m_noise_file);
QTest::qWait(200);
QVERIFY(duration_spy.count() > 0);
QCOMPARE(error_spy.count(), 0);
QCOMPARE((int)player.getDuration(), 6);
QCOMPARE(player.getFilePath(), m_noise_file);
}
/** When loading an empty file, the error() signal should be emitted. */
void AudioPlayerTest::loadErrorneousFile() {
AudioPlayer player;
QSignalSpy spy(&player, SIGNAL(error(const QString&)));
QString empty_file = QString(SRCDIR);
empty_file += "files/empty.wav";
player.openFile(empty_file);
QTest::qWait(200);
QCOMPARE(spy.count(), 1);
QList<QVariant> signal = spy.takeFirst();
QVERIFY(signal.at(0).toString().startsWith("The audio file can't be loaded."));
// We shouldn't be able to play the audio
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
player.togglePlayPause(true);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE(player.getFilePath(), empty_file); // Even when the file fails to
// load, the file name should be
// reported.
}
/** We should be able to load a different file. After loading, we should be in
* the PAUSED state. */
void AudioPlayerTest::loadDifferentFile() {
AudioPlayer player;
QSignalSpy spy(&player, SIGNAL(durationChanged()));
// Open the first audio file
player.openFile(m_noise_file);
QTest::qWait(200);
QVERIFY(spy.count() > 0); // durationChanged should have been emitted
QCOMPARE((int)player.getDuration(), 6); // noise.wav has a duration of 6 seconds
QCOMPARE(player.getState(), // We should be initalized in paused state
AudioPlayer::PAUSED);
QCOMPARE(player.getFilePath(), m_noise_file);
player.togglePlayPause(true);
QCOMPARE(player.getState(), AudioPlayer::PLAYING);
// Open alternative audio file
int num_signals = spy.count();
player.openFile(m_silence_file);
QTest::qWait(200);
QVERIFY(spy.count() > num_signals); // durationChanged should have been emitted
QCOMPARE((int)player.getDuration(), 7); // silence.wav has a duration of 7 seconds
QCOMPARE(player.getState(), // We should be initalized in paused state
AudioPlayer::PAUSED);
QCOMPARE(player.getFilePath(), m_silence_file);
}
/** Test if we can toggle between PLAYING and PAUSED state without setting the
* desired state explicitely (the strict sense of 'toggle') */
void AudioPlayerTest::togglePlayPause() {
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
m_player->togglePlayPause();
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
m_player->togglePlayPause();
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
}
/** Test if we can toggle between PLAYING and PAUSED state by setting the
* desired state explicitely (the strict sense of 'toggle') */
void AudioPlayerTest::togglePlayPauseWithArgument() {
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
m_player->togglePlayPause(true);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
m_player->togglePlayPause(false);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
}
/** Test if we can toggle between PLAYING and WAITING state. */
void AudioPlayerTest::toggleWaiting() {
m_player->togglePlayPause(true);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
m_player->toggleWaiting(true);
QCOMPARE(m_player->getState(), AudioPlayer::WAITING);
m_player->toggleWaiting(false);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
}
/** Test if the positionChangedSignal is emitted during playback and if the
* position is reported correctly. */
void AudioPlayerTest::positionChangedSignal() {
QSignalSpy spy(m_player, SIGNAL(positionChanged()));
m_player->togglePlayPause(true);
QTest::qWait(100);
int num_signals = spy.count();
QVERIFY(num_signals > 1); // At least one signal because of play start
// Play for 1100 ms. This should emit exactly one signal since the 'starting
// signals'
QTest::qWait(1100);
QCOMPARE(spy.count(), num_signals + 1); // Position changed signal
m_player->togglePlayPause(false);
QCOMPARE(spy.count(), num_signals + 2); // Signal because of play stop
QCOMPARE((int)m_player->getPosition(), 1); // Position should be at 1 second
}
/** Test for seeking and position changed signal changed signal. */
void AudioPlayerTest::seek() {
// We can't reuse the general AudioPlayer here, because it relies on this
// functionality to work correctly. So we need to create a separate instance.
AudioPlayer player;
player.openFile(m_noise_file);
QTest::qWait(200);
QSignalSpy spy(&player, SIGNAL(positionChanged()));
player.togglePlayPause(true);
// Seek forward
int num_signals = spy.count();
player.skipSeconds(4);
QVERIFY(spy.count() > num_signals);
QCOMPARE((int)player.getPosition(), 4);
// Seek backward
num_signals = spy.count();
player.skipSeconds(-2);
QVERIFY(spy.count() > num_signals);
QCOMPARE((int)player.getPosition(), 2);
// Make sure we can't seek before beginning
num_signals = spy.count();
player.skipSeconds(-10);
QVERIFY(spy.count() > num_signals);
QCOMPARE((int)player.getPosition(), 0);
// Make sure we can't seek past the end
num_signals = spy.count();
player.skipSeconds(20);
QVERIFY(spy.count() > num_signals);
QCOMPARE((int)player.getPosition(), 6);
QTest::qWait(200);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
player.togglePlayPause(false);
}
/** Test for setting the audio position explicitely. */
void AudioPlayerTest::setPosition() {
QCOMPARE((int)m_player->getPosition(), 0);
m_player->setPosition(3);
QCOMPARE((int)m_player->getPosition(), 3);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
// Make sure we can't set negative time
m_player->setPosition(-1);
QVERIFY(m_player->getPosition() == 0);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
// Make sure we can't set time past the end
m_player->setPosition(100);
QCOMPARE((int)m_player->getPosition(), 6);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
// --- Now do the same while playing
m_player->togglePlayPause(true);
m_player->setPosition(0);
QCOMPARE((int)m_player->getPosition(), 0);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
m_player->setPosition(3);
QCOMPARE((int)m_player->getPosition(), 3);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
// Make sure we can't set negative time
m_player->setPosition(-1);
QVERIFY(m_player->getPosition() == 0);
QCOMPARE(m_player->getState(), AudioPlayer::PLAYING);
// Make sure we can't set time past the end
m_player->setPosition(100);
QTest::qWait(100);
QCOMPARE((int)m_player->getPosition(), 6);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
// Make sure we don't resume playing because just because of the seeking
m_player->setPosition(3);
QVERIFY(m_player->getPosition() == 3);
QCOMPARE(m_player->getState(), AudioPlayer::PAUSED);
}
/** Test if durations and positions are properly rounded to whole seconds. */
void AudioPlayerTest::timeRounding() {
// Our test file takes 5.8 seconds, which should round the result to 6
QCOMPARE((int)m_player->getDuration(), 6);
// Load the silence file, which takes 7.0 seconds and should be rounded to 7
AudioPlayer player;
player.openFile(m_silence_file);
QTest::qWait(200);
QCOMPARE((int)player.getDuration(), 7);
// Make sure we're rounded to the nearest number of seconds in our position
m_player->togglePlayPause(true);
QTest::qWait(600);
m_player->togglePlayPause(false);
QCOMPARE((int)m_player->getPosition(), 1);
m_player->togglePlayPause(true);
QTest::qWait(600);
m_player->togglePlayPause(false);
QCOMPARE((int)m_player->getPosition(), 1);
m_player->togglePlayPause(true);
QTest::qWait(600);
m_player->togglePlayPause(false);
QCOMPARE((int)m_player->getPosition(), 2);
}
/** Test for the accepted state transmissions.
* This method re-tests some of the functionality previously verified. We
* still keep the different tests though, as they aim for different concepts
* which we now have out there in the open. */
void AudioPlayerTest::stateTransitions() {
// We can't reuse the general AudioPlayer here, because it relies on this
// functionality to work correctly. So we need to create a separate instance.
AudioPlayer player;
player.openFile(m_noise_file);
QTest::qWait(200);
QSignalSpy spy(&player, SIGNAL(stateChanged()));
// paused -> playing: ok
player.togglePlayPause(true);
QCOMPARE(player.getState(), AudioPlayer::PLAYING);
QCOMPARE(spy.count(), 1);
// playing -> playing: ok
player.togglePlayPause(true);
QCOMPARE(player.getState(), AudioPlayer::PLAYING);
QCOMPARE(spy.count(), 1); // No signal emitted
// playing -> waiting: ok
player.toggleWaiting(true);
QCOMPARE(player.getState(), AudioPlayer::WAITING);
QCOMPARE(spy.count(), 2);
// waiting -> waiting: ok
player.toggleWaiting(true);
QCOMPARE(player.getState(), AudioPlayer::WAITING);
QCOMPARE(spy.count(), 2); // No signal emitted
// waiting -> playing: ok
player.toggleWaiting(false);
QCOMPARE(player.getState(), AudioPlayer::PLAYING);
QCOMPARE(spy.count(), 3);
// playing -> paused: ok
player.togglePlayPause(false);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE(spy.count(), 4);
// paused -> paused: ok
player.togglePlayPause(false);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE(spy.count(), 4); // No signal emitted
// paused -> waiting: fail
player.toggleWaiting(true);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE(spy.count(), 4); // No signal emitted
// waiting -> paused: ok
player.togglePlayPause(true);
player.toggleWaiting(true);
QCOMPARE(spy.count(), 6);
QCOMPARE(player.getState(), AudioPlayer::WAITING);
player.togglePlayPause(false);
QCOMPARE(player.getState(), AudioPlayer::PAUSED);
QCOMPARE(spy.count(), 7);
}
| 33.753799 | 85 | 0.711121 | p-edelman |
470c8ee4b934bb2b70623fc622a9a7c999e71882 | 1,716 | cpp | C++ | default.cpp | LucasGMeneses/OpenGL_labs | ddf753c29cc2fcb07cd0ad04b16f03958b8e452f | [
"MIT"
] | null | null | null | default.cpp | LucasGMeneses/OpenGL_labs | ddf753c29cc2fcb07cd0ad04b16f03958b8e452f | [
"MIT"
] | null | null | null | default.cpp | LucasGMeneses/OpenGL_labs | ddf753c29cc2fcb07cd0ad04b16f03958b8e452f | [
"MIT"
] | 1 | 2020-11-24T16:27:14.000Z | 2020-11-24T16:27:14.000Z | /*
* To compile with windows -lfreeglut -lglu32 -lopengl32
* To compile linux -lglut -lGL -lGLU -lm
*/
#include <GL/freeglut.h> // ou glut.h - GLUT, include glu.h and gl.h
#include <math.h>
#include <stdio.h>
/* Initialize OpenGL Graphics */
void init() {
// Set "clearing" or background color
glClearColor(0, 0, 0, 1); // Black and opaque
}
/* Handler for window-repaint event. Call back when the window first appears and
whenever the window needs to be re-painted. */
void display() {
glClear(GL_COLOR_BUFFER_BIT); // Clear the color buffer (background)
//draw objects//
glFlush(); // Render now
}
/* Handler for window re-size event. Called back when the window first appears and
whenever the window is re-sized with its new width and height */
void reshape(GLsizei width, GLsizei height) { // GLsizei for non-negative integer
// Compute aspect ratio of the new window
}
/* Main function: GLUT runs as a console application starting at main() */
int main(int argc, char** argv) {
glutInit(&argc, argv); // Initialize GLUT
glutInitWindowSize(480, 480); // Set the window's initial width & height - non-square
glutInitWindowPosition(50, 50); // Position the window's initial top-left corner
glutCreateWindow("Window"); // Create window with the given title
glutDisplayFunc(display); // Register callback handler for window re-paint event
glutIdleFunc(display);
glutReshapeFunc(reshape); // Register callback handler for window re-size event
init(); // Our own OpenGL initialization
glutMainLoop(); // Enter the infinite event-processing loop
return 0;
}
| 35.75 | 90 | 0.67366 | LucasGMeneses |
471044001670035c699bc00ca1fe395c87bb1098 | 11,597 | hpp | C++ | cisco-ios-xe/ydk/models/cisco_ios_xe/CISCO_ENTITY_EXT_MIB.hpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 17 | 2016-12-02T05:45:49.000Z | 2022-02-10T19:32:54.000Z | cisco-ios-xe/ydk/models/cisco_ios_xe/CISCO_ENTITY_EXT_MIB.hpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 2 | 2017-03-27T15:22:38.000Z | 2019-11-05T08:30:16.000Z | cisco-ios-xe/ydk/models/cisco_ios_xe/CISCO_ENTITY_EXT_MIB.hpp | CiscoDevNet/ydk-cpp | ef7d75970f2ef1154100e0f7b0a2ee823609b481 | [
"ECL-2.0",
"Apache-2.0"
] | 11 | 2016-12-02T05:45:52.000Z | 2019-11-07T08:28:17.000Z | #ifndef _CISCO_ENTITY_EXT_MIB_
#define _CISCO_ENTITY_EXT_MIB_
#include <memory>
#include <vector>
#include <string>
#include <ydk/types.hpp>
#include <ydk/errors.hpp>
namespace cisco_ios_xe {
namespace CISCO_ENTITY_EXT_MIB {
class CISCOENTITYEXTMIB : public ydk::Entity
{
public:
CISCOENTITYEXTMIB();
~CISCOENTITYEXTMIB();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::shared_ptr<ydk::Entity> clone_ptr() const override;
ydk::augment_capabilities_function get_augment_capabilities_function() const override;
std::string get_bundle_yang_models_location() const override;
std::string get_bundle_name() const override;
std::map<std::pair<std::string, std::string>, std::string> get_namespace_identity_lookup() const override;
class CeExtPhysicalProcessorTable; //type: CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable
class CeExtConfigRegTable; //type: CISCOENTITYEXTMIB::CeExtConfigRegTable
class CeExtEntityLEDTable; //type: CISCOENTITYEXTMIB::CeExtEntityLEDTable
std::shared_ptr<cisco_ios_xe::CISCO_ENTITY_EXT_MIB::CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable> ceextphysicalprocessortable;
std::shared_ptr<cisco_ios_xe::CISCO_ENTITY_EXT_MIB::CISCOENTITYEXTMIB::CeExtConfigRegTable> ceextconfigregtable;
std::shared_ptr<cisco_ios_xe::CISCO_ENTITY_EXT_MIB::CISCOENTITYEXTMIB::CeExtEntityLEDTable> ceextentityledtable;
}; // CISCOENTITYEXTMIB
class CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable : public ydk::Entity
{
public:
CeExtPhysicalProcessorTable();
~CeExtPhysicalProcessorTable();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
class CeExtPhysicalProcessorEntry; //type: CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable::CeExtPhysicalProcessorEntry
ydk::YList ceextphysicalprocessorentry;
}; // CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable
class CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable::CeExtPhysicalProcessorEntry : public ydk::Entity
{
public:
CeExtPhysicalProcessorEntry();
~CeExtPhysicalProcessorEntry();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
//type: int32 (refers to cisco_ios_xe::ENTITY_MIB::ENTITYMIB::EntPhysicalTable::EntPhysicalEntry::entphysicalindex)
ydk::YLeaf entphysicalindex;
ydk::YLeaf ceextprocessorram; //type: uint32
ydk::YLeaf ceextnvramsize; //type: uint32
ydk::YLeaf ceextnvramused; //type: uint32
ydk::YLeaf ceextprocessorramoverflow; //type: uint32
ydk::YLeaf ceexthcprocessorram; //type: uint64
}; // CISCOENTITYEXTMIB::CeExtPhysicalProcessorTable::CeExtPhysicalProcessorEntry
class CISCOENTITYEXTMIB::CeExtConfigRegTable : public ydk::Entity
{
public:
CeExtConfigRegTable();
~CeExtConfigRegTable();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
class CeExtConfigRegEntry; //type: CISCOENTITYEXTMIB::CeExtConfigRegTable::CeExtConfigRegEntry
ydk::YList ceextconfigregentry;
}; // CISCOENTITYEXTMIB::CeExtConfigRegTable
class CISCOENTITYEXTMIB::CeExtConfigRegTable::CeExtConfigRegEntry : public ydk::Entity
{
public:
CeExtConfigRegEntry();
~CeExtConfigRegEntry();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
//type: int32 (refers to cisco_ios_xe::ENTITY_MIB::ENTITYMIB::EntPhysicalTable::EntPhysicalEntry::entphysicalindex)
ydk::YLeaf entphysicalindex;
ydk::YLeaf ceextconfigregister; //type: string
ydk::YLeaf ceextconfigregnext; //type: string
ydk::YLeaf ceextsysbootimagelist; //type: binary
ydk::YLeaf ceextkickstartimagelist; //type: binary
}; // CISCOENTITYEXTMIB::CeExtConfigRegTable::CeExtConfigRegEntry
class CISCOENTITYEXTMIB::CeExtEntityLEDTable : public ydk::Entity
{
public:
CeExtEntityLEDTable();
~CeExtEntityLEDTable();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
class CeExtEntityLEDEntry; //type: CISCOENTITYEXTMIB::CeExtEntityLEDTable::CeExtEntityLEDEntry
ydk::YList ceextentityledentry;
}; // CISCOENTITYEXTMIB::CeExtEntityLEDTable
class CISCOENTITYEXTMIB::CeExtEntityLEDTable::CeExtEntityLEDEntry : public ydk::Entity
{
public:
CeExtEntityLEDEntry();
~CeExtEntityLEDEntry();
bool has_data() const override;
bool has_operation() const override;
std::vector<std::pair<std::string, ydk::LeafData> > get_name_leaf_data() const override;
std::string get_segment_path() const override;
std::shared_ptr<ydk::Entity> get_child_by_name(const std::string & yang_name, const std::string & segment_path) override;
void set_value(const std::string & value_path, const std::string & value, const std::string & name_space, const std::string & name_space_prefix) override;
void set_filter(const std::string & value_path, ydk::YFilter yfliter) override;
std::map<std::string, std::shared_ptr<ydk::Entity>> get_children() const override;
bool has_leaf_or_child_of_name(const std::string & name) const override;
std::string get_absolute_path() const override;
//type: int32 (refers to cisco_ios_xe::ENTITY_MIB::ENTITYMIB::EntPhysicalTable::EntPhysicalEntry::entphysicalindex)
ydk::YLeaf entphysicalindex;
ydk::YLeaf ceextentityledtype; //type: CeExtEntityLEDType
ydk::YLeaf ceextentityledcolor; //type: CeExtEntityLEDColor
class CeExtEntityLEDType;
class CeExtEntityLEDColor;
}; // CISCOENTITYEXTMIB::CeExtEntityLEDTable::CeExtEntityLEDEntry
class CISCOENTITYEXTMIB::CeExtEntityLEDTable::CeExtEntityLEDEntry::CeExtEntityLEDType : public ydk::Enum
{
public:
static const ydk::Enum::YLeaf status;
static const ydk::Enum::YLeaf system;
static const ydk::Enum::YLeaf active;
static const ydk::Enum::YLeaf power;
static const ydk::Enum::YLeaf battery;
static int get_enum_value(const std::string & name) {
if (name == "status") return 1;
if (name == "system") return 2;
if (name == "active") return 3;
if (name == "power") return 4;
if (name == "battery") return 5;
return -1;
}
};
class CISCOENTITYEXTMIB::CeExtEntityLEDTable::CeExtEntityLEDEntry::CeExtEntityLEDColor : public ydk::Enum
{
public:
static const ydk::Enum::YLeaf off;
static const ydk::Enum::YLeaf green;
static const ydk::Enum::YLeaf amber;
static const ydk::Enum::YLeaf red;
static int get_enum_value(const std::string & name) {
if (name == "off") return 1;
if (name == "green") return 2;
if (name == "amber") return 3;
if (name == "red") return 4;
return -1;
}
};
}
}
#endif /* _CISCO_ENTITY_EXT_MIB_ */
| 48.320833 | 162 | 0.706303 | CiscoDevNet |
4710910ee61020d26beefb3ffa8bf298b31fbecf | 18,273 | cpp | C++ | euchar/cppbinding/curve.cpp | gbeltramo/euchar | 3852a0800f078b26c125b83e28465ec66212cbec | [
"MIT"
] | null | null | null | euchar/cppbinding/curve.cpp | gbeltramo/euchar | 3852a0800f078b26c125b83e28465ec66212cbec | [
"MIT"
] | null | null | null | euchar/cppbinding/curve.cpp | gbeltramo/euchar | 3852a0800f078b26c125b83e28465ec66212cbec | [
"MIT"
] | null | null | null | #include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <numeric> // std::partial_sum, std::iota
#include <algorithm> // std::copy, std::lower_bound
using namespace std;
//================================================
int sum_bool_2d(vector<vector<bool>> matrix)
{
size_t numI = matrix.size();
size_t numJ = matrix[0].size();
int total = 0;
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
if (matrix[i][j] == true)
total += 1;
}
}
return total;
}
//================================================
vector<vector<int>> pad_2d(const vector<vector<int>> &image, int M)
{
size_t numI = image.size();
size_t numJ = image[0].size();
vector<vector<int>> padded(numI+2, vector<int>(numJ+2, M));
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
padded[i+1][j+1] = image[i][j];
}
}
return padded;
}
//================================================
vector<vector<bool>> threshold_image_2d(const vector<vector<int>> &image, int value)
{
size_t numI = image.size();
size_t numJ = image[0].size();
vector<vector<bool>> binary_thresh(numI, vector<bool>(numJ, false));
// Loop over all pixel in original image
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
if (image[i][j] <= value)
{
binary_thresh[i][j] = true;
}
}
}
return binary_thresh;
}
//================================================
vector<vector<bool>> elementwise_AND_2d(const vector<vector<bool>> &image1, const vector<vector<bool>> &image2)
{
size_t numI = image1.size();
size_t numJ = image1[0].size();
vector<vector<bool>> result(numI, vector<bool>(numJ, false));
// Loop over all pixel in original image
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
if (image1[i][j] == true && image2[i][j] == true) {
result[i][j] = true;
}
}
}
return result;
}
//================================================
vector<vector<int>> neigh_pixel_2d(const vector<vector<int>> &padded, size_t i , size_t j)
{
vector<vector<int>> neigh_3_3(3, vector<int>(3, 0));
neigh_3_3[0][0] = padded[i-1][j-1];
neigh_3_3[1][0] = padded[i][j-1];
neigh_3_3[2][0] = padded[i+1][j-1];
neigh_3_3[0][1] = padded[i-1][j];
neigh_3_3[1][1] = padded[i][j];
neigh_3_3[2][1] = padded[i+1][j];
neigh_3_3[0][2] = padded[i-1][j+1];
neigh_3_3[1][2] = padded[i][j+1];
neigh_3_3[2][2] = padded[i+1][j+1];
return neigh_3_3;
}
//================================================
vector<vector<bool>> binary_neigh_pixel_2d(const vector<vector<int>> &padded, size_t i , size_t j , int pixel_value)
{
vector<vector<int>> neigh_3_3 = neigh_pixel_2d(padded, i, j);
vector<vector<bool>> binary_neigh_3_3(3, vector<bool>(3, false));
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j) {
// need to take account of order pixels
// strinct inequality after central pixel
size_t k = j + i*3;
if (k < 5) { // up to central pixel included
if (neigh_3_3[i][j] <= pixel_value)
binary_neigh_3_3[i][j] = true;
} else {
if (neigh_3_3[i][j] < pixel_value)
binary_neigh_3_3[i][j] = true;
}
}
}
return binary_neigh_3_3;
}
//================================================
int char_binary_image_2d(vector<vector<bool>> input)
{
// Input shape: binary image number of rows and columns
size_t numI = input.size();
size_t numJ = input[0].size();
// Matrices for vectices, horizontal edges and vertical edges
vector<vector<bool>> V(numI+1, vector<bool>(numJ+1, false));
vector<vector<bool>> Eh(numI+1, vector<bool>(numJ, false));
vector<vector<bool>> Ev(numI, vector<bool>(numJ+1, false));
// Loop over pixels to update V, Eh, Ev
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
if (input[i][j] == true) {
V[i][j] = true;
V[i+1][j] = true;
V[i][j+1] = true;
V[i+1][j+1] = true;
Eh[i][j] = true;
Eh[i+1][j] = true;
Ev[i][j] = true;
Ev[i][j+1] = true;
}
}
}
// Sum of elements in the matrices
int v = sum_bool_2d(V);
int eh = sum_bool_2d(Eh);
int ev = sum_bool_2d(Ev);
int f = sum_bool_2d(input);
int EC = v - eh - ev + f;
return EC;
}
//================================================
size_t number_from_neigh_2d(vector<vector<bool>> neigh)
{
const vector<size_t> powers_of_two = {1, 2, 4, 8, 0,
16, 32, 64, 128};
size_t num = 0;
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j) {
if (neigh[i][j] == true) {
num |= powers_of_two[j+i*3];
}
}
}
return num;
}
//================================================
int sum_bool_3d(vector<vector<vector<bool>>> matrix)
{
size_t numI = matrix.size();
size_t numJ = matrix[0].size();
size_t numK = matrix[0][0].size();
int total = 0;
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
for (size_t k = 0; k < numK; ++k) {
if (matrix[i][j][k] == true)
total += 1;
}
}
}
return total;
}
//================================================
vector<vector<vector<int>>> pad_3d(const vector<vector<vector<int>>> &image, int M)
{
size_t numI = image.size();
size_t numJ = image[0].size();
size_t numK = image[0][0].size();
vector<vector<vector<int>>> padded(numI+2, vector<vector<int>>(numJ+2, vector<int>(numK+2, M)));
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
for (size_t k = 0; k < numK; ++k) {
padded[i+1][j+1][k+1] = image[i][j][k];
}
}
}
return padded;
}
//================================================
vector<vector<vector<bool>>> threshold_image_3d(const vector<vector<vector<int>>> &image, int value)
{
size_t numI = image.size();
size_t numJ = image[0].size();
size_t numK = image[0][0].size();
vector<vector<vector<bool>>> binary_thresh(numI, vector<vector<bool>>(numJ, vector<bool>(numK, false)));
// Loop over all pixel in original image
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
for (size_t k = 0; k < numK; ++k) {
if (image[i][j][k] <= value) {
binary_thresh[i][j][k] = true;
}
}
}
}
return binary_thresh;
}
//================================================
vector<vector<vector<bool>>> elementwise_AND_3d(const vector<vector<vector<bool>>> &image1, const vector<vector<vector<bool>>> &image2)
{
size_t numI = image1.size();
size_t numJ = image1[0].size();
size_t numK = image1[0][0].size();
vector<vector<vector<bool>>> result(numI, vector<vector<bool>>(numJ, vector<bool>(numK, false)));
// Loop over all pixel in original image
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
for (size_t k = 0; k < numK; ++k) {
if (image1[i][j][k] == true && image2[i][j][k] == true) {
result[i][j][k] = true;
}
}
}
}
return result;
}
//================================================
vector<vector<vector<int>>> neigh_voxel_3d(const vector<vector<vector<int>>> &padded, size_t i , size_t j , size_t k)
{
vector<vector<vector<int>>> neigh_3_3_3(3, vector<vector<int>>(3, vector<int>(3, 0)));
neigh_3_3_3[0][0][0] = padded[i-1][j-1][k-1];
neigh_3_3_3[1][0][0] = padded[i][j-1][k-1];
neigh_3_3_3[2][0][0] = padded[i+1][j-1][k-1];
neigh_3_3_3[0][1][0] = padded[i-1][j][k-1];
neigh_3_3_3[1][1][0] = padded[i][j][k-1];
neigh_3_3_3[2][1][0] = padded[i+1][j][k-1];
neigh_3_3_3[0][2][0] = padded[i-1][j+1][k-1];
neigh_3_3_3[1][2][0] = padded[i][j+1][k-1];
neigh_3_3_3[2][2][0] = padded[i+1][j+1][k-1];
neigh_3_3_3[0][0][1] = padded[i-1][j-1][k];
neigh_3_3_3[1][0][1] = padded[i][j-1][k];
neigh_3_3_3[2][0][1] = padded[i+1][j-1][k];
neigh_3_3_3[0][1][1] = padded[i-1][j][k];
neigh_3_3_3[1][1][1] = padded[i][j][k];
neigh_3_3_3[2][1][1] = padded[i+1][j][k];
neigh_3_3_3[0][2][1] = padded[i-1][j+1][k];
neigh_3_3_3[1][2][1] = padded[i][j+1][k];
neigh_3_3_3[2][2][1] = padded[i+1][j+1][k];
neigh_3_3_3[0][0][2] = padded[i-1][j-1][k+1];
neigh_3_3_3[1][0][2] = padded[i][j-1][k+1];
neigh_3_3_3[2][0][2] = padded[i+1][j-1][k+1];
neigh_3_3_3[0][1][2] = padded[i-1][j][k+1];
neigh_3_3_3[1][1][2] = padded[i][j][k+1];
neigh_3_3_3[2][1][2] = padded[i+1][j][k+1];
neigh_3_3_3[0][2][2] = padded[i-1][j+1][k+1];
neigh_3_3_3[1][2][2] = padded[i][j+1][k+1];
neigh_3_3_3[2][2][2] = padded[i+1][j+1][k+1];
return neigh_3_3_3;
}
//================================================
vector<vector<vector<bool>>> binary_neigh_voxel_3d(const vector<vector<vector<int>>> &padded, size_t i , size_t j , size_t k, int voxel_value)
{
vector<vector<vector<int>>> neigh_3_3_3 = neigh_voxel_3d(padded, i, j, k);
vector<vector<vector<bool>>> binary_neigh_3_3_3(3, vector<vector<bool>>(3, vector<bool>(3, false)));
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j) {
for (size_t k = 0; k < 3; ++k) {
// need to take account of order pixels
// strinct inequality after central pixel
size_t s = k + j*3 + i*9;
if (s < 14) { // up to central pixel included
if (neigh_3_3_3[i][j][k] <= voxel_value)
binary_neigh_3_3_3[i][j][k] = true;
} else {
if (neigh_3_3_3[i][j][k] < voxel_value)
binary_neigh_3_3_3[i][j][k] = true;
}
}
}
}
return binary_neigh_3_3_3;
}
//================================================
int char_binary_image_3d(vector<vector<vector<bool>>> input)
{
size_t numI = input.size();
size_t numJ = input[0].size();
size_t numK = input[0][0].size();
vector<vector<vector<bool>>> V(numI+1, vector<vector<bool>>(numJ+1, vector<bool>(numK+1, false)));
vector<vector<vector<bool>>> Ei(numI, vector<vector<bool>>(numJ+1, vector<bool>(numK+1, false)));
vector<vector<vector<bool>>> Ej(numI+1, vector<vector<bool>>(numJ, vector<bool>(numK+1, false)));
vector<vector<vector<bool>>> Ek(numI+1, vector<vector<bool>>(numJ+1, vector<bool>(numK, false)));
vector<vector<vector<bool>>> Fij(numI, vector<vector<bool>>(numJ, vector<bool>(numK+1, false)));
vector<vector<vector<bool>>> Fik(numI, vector<vector<bool>>(numJ+1, vector<bool>(numK, false)));
vector<vector<vector<bool>>> Fjk(numI+1, vector<vector<bool>>(numJ, vector<bool>(numK, false)));
vector<vector<vector<bool>>> C(numI, vector<vector<bool>>(numJ, vector<bool>(numK, false)));
for (size_t i = 0; i < numI; ++i) {
for (size_t j = 0; j < numJ; ++j) {
for (size_t k = 0; k < numK; ++k) {
if (input[i][j][k] == true) {
V[i][j][k] = true;
V[i+1][j][k] = true;
V[i][j+1][k] = true;
V[i][j][k+1] = true;
V[i+1][j+1][k] = true;
V[i+1][j][k+1] = true;
V[i][j+1][k+1] = true;
V[i+1][j+1][k+1] = true;
Ei[i][j][k] = true;
Ei[i][j+1][k] = true;
Ei[i][j][k+1] = true;
Ei[i][j+1][k+1] = true;
Ej[i][j][k] = true;
Ej[i+1][j][k] = true;
Ej[i][j][k+1] = true;
Ej[i+1][j][k+1] = true;
Ek[i][j][k] = true;
Ek[i][j+1][k] = true;
Ek[i+1][j][k] = true;
Ek[i+1][j+1][k] = true;
Fij[i][j][k] = true;
Fij[i][j][k+1] = true;
Fik[i][j][k] = true;
Fik[i][j+1][k] = true;
Fjk[i][j][k] = true;
Fjk[i+1][j][k] = true;
C[i][j][k] = true;
}
}
}
}
int v = sum_bool_3d(V);
int ei = sum_bool_3d(Ei);
int ej = sum_bool_3d(Ej);
int ek = sum_bool_3d(Ek);
int fij = sum_bool_3d(Fij);
int fik = sum_bool_3d(Fik);
int fjk = sum_bool_3d(Fjk);
int c = sum_bool_3d(C);
int EC = v - ei - ej - ek + fij + fik + fjk - c;
return EC;
}
//================================================
size_t number_from_neigh_3d(vector<vector<vector<bool>>> neigh)
{
size_t num = 0;
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j){
for (size_t k = 0; k < 3; ++k) {
size_t bits_shift = static_cast<size_t>(1ULL << (k + j*3 + i * 9));
size_t bits_shift_minus_1 = static_cast<size_t>(1ULL << (k + j*3 + i * 9 - 1));
if (bits_shift < 8192) { // 2^13 == 8192, and 14th
// voxel is central one
if (neigh[i][j][k] == true)
num |= bits_shift;
} else if (bits_shift > 8192)
{
if (neigh[i][j][k] == true)
num |= bits_shift_minus_1;
}
}
}
}
return num;
}
//================================================
vector<int> naive_image_2d(vector<vector<int>> image, int M)
{
vector<int> ecc(M+1, 0);
for (size_t i = 0; i < M+1; ++i) {
vector<vector<bool>> thresh_image = threshold_image_2d(image, static_cast<int>(i));
ecc[i] = char_binary_image_2d(thresh_image);
}
return ecc;
}
//================================================
vector<int> image_2d(const vector<vector<int>> & image,
const vector<int> &vector_euler_changes,
int M)
{
size_t numI = image.size();
size_t numJ = image[0].size();
vector<int> ecc(M+1, 0);
vector<vector<int>> padded = pad_2d(image, M+1);
for (size_t i = 1; i < numI+1; ++i) {
for (size_t j = 1; j < numJ+1; ++j) {
int pixel_value = padded[i][j];
vector<vector<bool>> binary_neigh_3_3 = binary_neigh_pixel_2d(padded, i, j, pixel_value);
size_t num = number_from_neigh_2d(binary_neigh_3_3);
ecc[static_cast<size_t>(pixel_value)] += static_cast<int>(vector_euler_changes[num]);
}
}
// Cumulative sum of euler changes
partial_sum(ecc.begin(), ecc.end(), ecc.begin());
return ecc;
}
//================================================
vector<int> naive_image_3d(vector<vector<vector<int>>> image, int M)
{
vector<int> ecc(M+1, 0);
for (size_t i = 0; i < M+1; ++i) {
vector<vector<vector<bool>>> binary_thresh = threshold_image_3d(image, static_cast<int>(i));
ecc[i] = char_binary_image_3d(binary_thresh);
}
return ecc;
}
//================================================
vector<int> image_3d(const vector<vector<vector<int>>> &image,
const vector<int> &vector_euler_changes,
int M)
{
size_t numI = image.size();
size_t numJ = image[0].size();
size_t numK = image[0][0].size();
vector<int> ecc(M+1, 0);
vector<vector<vector<int>>> padded = pad_3d(image, M+1);
for (size_t i = 1; i < numI+1; ++i) {
for (size_t j = 1; j < numJ+1; ++j) {
for (size_t k = 1; k < numK+1; ++k) {
int voxel_value = padded[i][j][k];
vector<vector<vector<bool>>> binary_neigh_3_3_3 = binary_neigh_voxel_3d(padded, i, j, k, voxel_value);
size_t num = number_from_neigh_3d(binary_neigh_3_3_3);
ecc[static_cast<size_t>(voxel_value)] += static_cast<int>(vector_euler_changes[num]);
}
}
}
// Cumulative sum of euler changes
partial_sum(ecc.begin(), ecc.end(), ecc.begin());
return ecc;
}
//================================================
vector<int> filtration(vector<int> dim_simplices,
vector<double> parametrization,
vector<double> bins)
{
size_t num_elements = bins.size();
vector<int> euler_char_curve(num_elements, 0);
// possible changes due to addition of vertex edge or triangle
vector<int> possible_changes{1, -1, 1, -1};
// loop on simplices and update euler curve
for (size_t i = 0; i < dim_simplices.size(); ++i) {
size_t dim_simplex = dim_simplices[i];
double par = parametrization[i];
vector<double>::iterator lower;
lower = lower_bound(bins.begin(), bins.end(), par);
euler_char_curve[(lower - bins.begin())] += possible_changes[dim_simplex];
}
int tmp = euler_char_curve[0];
for (size_t s = 1; s < euler_char_curve.size(); ++s) {
euler_char_curve[s] += tmp;
tmp = euler_char_curve[s];
}
return euler_char_curve;
}
//================================================
PYBIND11_MODULE(curve, m) {
m.doc() = "Euler characteristic curves cpp bindings.";
m.def("naive_image_2d", &naive_image_2d);
m.def("image_2d", &image_2d);
m.def("naive_image_3d", &naive_image_3d);
m.def("image_3d", &image_3d);
m.def("filtration", &filtration);
#ifdef VERSION_INFO
m.attr("__version__") = VERSION_INFO;
#else
m.attr("__version__") = "dev";
#endif
}
| 30.710924 | 142 | 0.482734 | gbeltramo |
4710d506446d1b3aa5751a08b09a174046f1085a | 36,512 | cpp | C++ | src/renderer/vulkan/renderpass/Culling.cpp | Ryp/Reaper | ccaef540013db7e8bf873db6e597e9036184d100 | [
"MIT"
] | 11 | 2016-11-07T07:47:46.000Z | 2018-07-19T16:04:45.000Z | src/renderer/vulkan/renderpass/Culling.cpp | Ryp/Reaper | ccaef540013db7e8bf873db6e597e9036184d100 | [
"MIT"
] | null | null | null | src/renderer/vulkan/renderpass/Culling.cpp | Ryp/Reaper | ccaef540013db7e8bf873db6e597e9036184d100 | [
"MIT"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////
/// Reaper
///
/// Copyright (c) 2015-2022 Thibault Schueller
/// This file is distributed under the MIT License
////////////////////////////////////////////////////////////////////////////////
#include "Culling.h"
#include "renderer/PrepareBuckets.h"
#include "renderer/vulkan/Backend.h"
#include "renderer/vulkan/Barrier.h"
#include "renderer/vulkan/CommandBuffer.h"
#include "renderer/vulkan/ComputeHelper.h"
#include "renderer/vulkan/Debug.h"
#include "renderer/vulkan/GpuProfile.h"
#include "renderer/vulkan/MeshCache.h"
#include "renderer/vulkan/Shader.h"
#include "common/Log.h"
#include "common/ReaperRoot.h"
#include <array>
#include <glm/gtc/matrix_transform.hpp>
#include "renderer/shader/share/meshlet.hlsl"
#include "renderer/shader/share/meshlet_culling.hlsl"
namespace Reaper
{
constexpr u32 IndexSizeBytes = 4;
constexpr u32 MaxCullPassCount = 4;
constexpr u32 MaxCullInstanceCount = 512 * MaxCullPassCount;
constexpr u32 MaxSurvivingMeshletsPerPass = 200;
// Worst case if all meshlets of all passes aren't culled.
// This shouldn't happen, we can probably cut this by half and raise a warning when we cross the limit.
constexpr u64 DynamicIndexBufferSizeBytes =
MaxSurvivingMeshletsPerPass * MaxCullPassCount * MeshletMaxTriangleCount * 3 * IndexSizeBytes;
constexpr u32 MaxIndirectDrawCountPerPass = MaxSurvivingMeshletsPerPass;
namespace
{
std::vector<VkDescriptorSet> create_descriptor_sets(VulkanBackend& backend, VkDescriptorSetLayout set_layout,
u32 count)
{
std::vector<VkDescriptorSetLayout> layouts(count, set_layout);
std::vector<VkDescriptorSet> sets(layouts.size());
const VkDescriptorSetAllocateInfo allocInfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, nullptr,
backend.global_descriptor_pool, static_cast<u32>(layouts.size()),
layouts.data()};
Assert(vkAllocateDescriptorSets(backend.device, &allocInfo, sets.data()) == VK_SUCCESS);
return sets;
}
void update_cull_meshlet_descriptor_sets(VulkanBackend& backend, CullResources& resources,
const BufferInfo& meshletBuffer, u32 pass_index)
{
VkDescriptorSet descriptor_set = resources.cull_meshlet_descriptor_sets[pass_index];
const VkDescriptorBufferInfo meshlets = default_descriptor_buffer_info(meshletBuffer);
const VkDescriptorBufferInfo instanceParams =
default_descriptor_buffer_info(resources.cullInstanceParamsBuffer);
const VkDescriptorBufferInfo counters = get_vk_descriptor_buffer_info(
resources.countersBuffer, BufferSubresource{pass_index * CountersCount, CountersCount});
const VkDescriptorBufferInfo meshlet_offsets = get_vk_descriptor_buffer_info(
resources.dynamicMeshletBuffer,
BufferSubresource{pass_index * MaxSurvivingMeshletsPerPass, MaxSurvivingMeshletsPerPass});
std::vector<VkWriteDescriptorSet> writes = {
create_buffer_descriptor_write(descriptor_set, 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &meshlets),
create_buffer_descriptor_write(descriptor_set, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &instanceParams),
create_buffer_descriptor_write(descriptor_set, 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &counters),
create_buffer_descriptor_write(descriptor_set, 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &meshlet_offsets),
};
vkUpdateDescriptorSets(backend.device, static_cast<u32>(writes.size()), writes.data(), 0, nullptr);
}
void update_culling_descriptor_sets(VulkanBackend& backend, CullResources& resources,
const BufferInfo& staticIndexBuffer, const BufferInfo& vertexBufferPosition,
u32 pass_index)
{
VkDescriptorSet descriptor_set = resources.cull_triangles_descriptor_sets[pass_index];
const VkDescriptorBufferInfo meshlets = get_vk_descriptor_buffer_info(
resources.dynamicMeshletBuffer,
BufferSubresource{pass_index * MaxSurvivingMeshletsPerPass, MaxSurvivingMeshletsPerPass});
const VkDescriptorBufferInfo indices = default_descriptor_buffer_info(staticIndexBuffer);
const VkDescriptorBufferInfo vertexPositions = default_descriptor_buffer_info(vertexBufferPosition);
const VkDescriptorBufferInfo instanceParams =
default_descriptor_buffer_info(resources.cullInstanceParamsBuffer);
const VkDescriptorBufferInfo indicesOut = get_vk_descriptor_buffer_info(
resources.dynamicIndexBuffer,
BufferSubresource{pass_index * DynamicIndexBufferSizeBytes, DynamicIndexBufferSizeBytes});
const VkDescriptorBufferInfo drawCommandOut = get_vk_descriptor_buffer_info(
resources.indirectDrawBuffer,
BufferSubresource{pass_index * MaxIndirectDrawCountPerPass, MaxIndirectDrawCountPerPass});
const VkDescriptorBufferInfo countersOut = get_vk_descriptor_buffer_info(
resources.countersBuffer, BufferSubresource{pass_index * CountersCount, CountersCount});
std::vector<VkWriteDescriptorSet> writes = {
create_buffer_descriptor_write(descriptor_set, 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &meshlets),
create_buffer_descriptor_write(descriptor_set, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &indices),
create_buffer_descriptor_write(descriptor_set, 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &vertexPositions),
create_buffer_descriptor_write(descriptor_set, 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &instanceParams),
create_buffer_descriptor_write(descriptor_set, 4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &indicesOut),
create_buffer_descriptor_write(descriptor_set, 5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &drawCommandOut),
create_buffer_descriptor_write(descriptor_set, 6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &countersOut),
};
vkUpdateDescriptorSets(backend.device, static_cast<u32>(writes.size()), writes.data(), 0, nullptr);
}
void update_cull_prepare_indirect_descriptor_set(VulkanBackend& backend, CullResources& resources,
VkDescriptorSet descriptor_set)
{
const VkDescriptorBufferInfo counters = default_descriptor_buffer_info(resources.countersBuffer);
const VkDescriptorBufferInfo indirectCommands =
default_descriptor_buffer_info(resources.indirectDispatchBuffer);
std::vector<VkWriteDescriptorSet> writes = {
create_buffer_descriptor_write(descriptor_set, 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &counters),
create_buffer_descriptor_write(descriptor_set, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &indirectCommands),
};
vkUpdateDescriptorSets(backend.device, static_cast<u32>(writes.size()), writes.data(), 0, nullptr);
}
SimplePipeline create_meshlet_prepare_indirect_pipeline(ReaperRoot& root, VulkanBackend& backend)
{
const char* fileName = "./build/shader/prepare_fine_culling_indirect.comp.spv";
const char* entryPoint = "main";
VkSpecializationInfo* specialization = nullptr;
VkShaderModule computeShader = vulkan_create_shader_module(backend.device, fileName);
std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBinding = {
VkDescriptorSetLayoutBinding{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
};
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0,
static_cast<u32>(descriptorSetLayoutBinding.size()), descriptorSetLayoutBinding.data()};
VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
Assert(vkCreateDescriptorSetLayout(backend.device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout)
== VK_SUCCESS);
log_debug(root, "vulkan: created descriptor set layout with handle: {}",
static_cast<void*>(descriptorSetLayout));
const VkPushConstantRange cullPushConstantRange = {VK_SHADER_STAGE_COMPUTE_BIT, 0,
sizeof(CullMeshletPushConstants)};
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
nullptr,
VK_FLAGS_NONE,
1,
&descriptorSetLayout,
1,
&cullPushConstantRange};
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
Assert(vkCreatePipelineLayout(backend.device, &pipelineLayoutInfo, nullptr, &pipelineLayout) == VK_SUCCESS);
log_debug(root, "vulkan: created pipeline layout with handle: {}", static_cast<void*>(pipelineLayout));
VkPipelineShaderStageCreateInfo shaderStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
nullptr,
0,
VK_SHADER_STAGE_COMPUTE_BIT,
computeShader,
entryPoint,
specialization};
VkComputePipelineCreateInfo pipelineCreateInfo = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
nullptr,
0,
shaderStage,
pipelineLayout,
VK_NULL_HANDLE, // do not care about pipeline derivatives
0};
VkPipeline pipeline = VK_NULL_HANDLE;
VkPipelineCache cache = VK_NULL_HANDLE;
Assert(vkCreateComputePipelines(backend.device, cache, 1, &pipelineCreateInfo, nullptr, &pipeline)
== VK_SUCCESS);
vkDestroyShaderModule(backend.device, computeShader, nullptr);
log_debug(root, "vulkan: created compute pipeline with handle: {}", static_cast<void*>(pipeline));
return SimplePipeline{pipeline, pipelineLayout, descriptorSetLayout};
}
SimplePipeline create_cull_meshlet_pipeline(ReaperRoot& root, VulkanBackend& backend)
{
const char* fileName = "./build/shader/cull_meshlet.comp.spv";
const char* entryPoint = "main";
VkSpecializationInfo* specialization = nullptr;
VkShaderModule computeShader = vulkan_create_shader_module(backend.device, fileName);
std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBinding = {
VkDescriptorSetLayoutBinding{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
};
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0,
static_cast<u32>(descriptorSetLayoutBinding.size()), descriptorSetLayoutBinding.data()};
VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
Assert(vkCreateDescriptorSetLayout(backend.device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout)
== VK_SUCCESS);
log_debug(root, "vulkan: created descriptor set layout with handle: {}",
static_cast<void*>(descriptorSetLayout));
const VkPushConstantRange cullPushConstantRange = {VK_SHADER_STAGE_COMPUTE_BIT, 0,
sizeof(CullMeshletPushConstants)};
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
nullptr,
VK_FLAGS_NONE,
1,
&descriptorSetLayout,
1,
&cullPushConstantRange};
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
Assert(vkCreatePipelineLayout(backend.device, &pipelineLayoutInfo, nullptr, &pipelineLayout) == VK_SUCCESS);
log_debug(root, "vulkan: created pipeline layout with handle: {}", static_cast<void*>(pipelineLayout));
VkPipelineShaderStageCreateInfo shaderStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
nullptr,
0,
VK_SHADER_STAGE_COMPUTE_BIT,
computeShader,
entryPoint,
specialization};
VkComputePipelineCreateInfo pipelineCreateInfo = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
nullptr,
0,
shaderStage,
pipelineLayout,
VK_NULL_HANDLE, // do not care about pipeline derivatives
0};
VkPipeline pipeline = VK_NULL_HANDLE;
VkPipelineCache cache = VK_NULL_HANDLE;
Assert(vkCreateComputePipelines(backend.device, cache, 1, &pipelineCreateInfo, nullptr, &pipeline)
== VK_SUCCESS);
vkDestroyShaderModule(backend.device, computeShader, nullptr);
log_debug(root, "vulkan: created compute pipeline with handle: {}", static_cast<void*>(pipeline));
return SimplePipeline{pipeline, pipelineLayout, descriptorSetLayout};
}
SimplePipeline create_cull_triangles_pipeline(ReaperRoot& root, VulkanBackend& backend)
{
std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBinding = {
VkDescriptorSetLayoutBinding{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
VkDescriptorSetLayoutBinding{6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr},
};
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, nullptr, 0,
static_cast<u32>(descriptorSetLayoutBinding.size()), descriptorSetLayoutBinding.data()};
VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
Assert(vkCreateDescriptorSetLayout(backend.device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout)
== VK_SUCCESS);
log_debug(root, "vulkan: created descriptor set layout with handle: {}",
static_cast<void*>(descriptorSetLayout));
const VkPushConstantRange cullPushConstantRange = {VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(CullPushConstants)};
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
nullptr,
VK_FLAGS_NONE,
1,
&descriptorSetLayout,
1,
&cullPushConstantRange};
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
Assert(vkCreatePipelineLayout(backend.device, &pipelineLayoutInfo, nullptr, &pipelineLayout) == VK_SUCCESS);
log_debug(root, "vulkan: created pipeline layout with handle: {}", static_cast<void*>(pipelineLayout));
const char* fileName = "./build/shader/cull_triangle_batch.comp.spv";
const char* entryPoint = "main";
VkSpecializationInfo* specialization = nullptr;
VkShaderModule computeShader = vulkan_create_shader_module(backend.device, fileName);
VkPipelineShaderStageCreateInfo shaderStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
nullptr,
0,
VK_SHADER_STAGE_COMPUTE_BIT,
computeShader,
entryPoint,
specialization};
VkComputePipelineCreateInfo pipelineCreateInfo = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
nullptr,
0,
shaderStage,
pipelineLayout,
VK_NULL_HANDLE, // do not care about pipeline derivatives
0};
VkPipeline pipeline = VK_NULL_HANDLE;
VkPipelineCache cache = VK_NULL_HANDLE;
Assert(vkCreateComputePipelines(backend.device, cache, 1, &pipelineCreateInfo, nullptr, &pipeline)
== VK_SUCCESS);
vkDestroyShaderModule(backend.device, computeShader, nullptr);
log_debug(root, "vulkan: created compute pipeline with handle: {}", static_cast<void*>(pipeline));
return SimplePipeline{pipeline, pipelineLayout, descriptorSetLayout};
}
} // namespace
CullResources create_culling_resources(ReaperRoot& root, VulkanBackend& backend)
{
CullResources resources;
resources.cullMeshletPipe = create_cull_meshlet_pipeline(root, backend);
resources.cullMeshletPrepIndirect = create_meshlet_prepare_indirect_pipeline(root, backend);
resources.cullTrianglesPipe = create_cull_triangles_pipeline(root, backend);
resources.cullInstanceParamsBuffer = create_buffer(
root, backend.device, "Culling instance constants",
DefaultGPUBufferProperties(MaxCullInstanceCount, sizeof(CullMeshInstanceParams), GPUBufferUsage::StorageBuffer),
backend.vma_instance, MemUsage::CPU_To_GPU);
resources.countersBuffer =
create_buffer(root, backend.device, "Meshlet counters",
DefaultGPUBufferProperties(CountersCount * MaxCullPassCount, sizeof(u32),
GPUBufferUsage::IndirectBuffer | GPUBufferUsage::TransferSrc
| GPUBufferUsage::TransferDst | GPUBufferUsage::StorageBuffer),
backend.vma_instance);
resources.countersBufferCPU = create_buffer(
root, backend.device, "Meshlet counters CPU",
DefaultGPUBufferProperties(CountersCount * MaxCullPassCount, sizeof(u32), GPUBufferUsage::TransferDst),
backend.vma_instance, MemUsage::CPU_Only);
resources.dynamicMeshletBuffer =
create_buffer(root, backend.device, "Dynamic meshlet offsets",
DefaultGPUBufferProperties(MaxSurvivingMeshletsPerPass * MaxCullPassCount, sizeof(MeshletOffsets),
GPUBufferUsage::StorageBuffer),
backend.vma_instance);
resources.indirectDispatchBuffer =
create_buffer(root, backend.device, "Indirect dispatch buffer",
DefaultGPUBufferProperties(MaxCullPassCount, sizeof(VkDispatchIndirectCommand),
GPUBufferUsage::IndirectBuffer | GPUBufferUsage::StorageBuffer),
backend.vma_instance);
resources.dynamicIndexBuffer =
create_buffer(root, backend.device, "Dynamic indices",
DefaultGPUBufferProperties(DynamicIndexBufferSizeBytes * MaxCullPassCount, 1,
GPUBufferUsage::IndexBuffer | GPUBufferUsage::StorageBuffer),
backend.vma_instance);
resources.indirectDrawBuffer = create_buffer(
root, backend.device, "Indirect draw buffer",
DefaultGPUBufferProperties(MaxIndirectDrawCountPerPass * MaxCullPassCount, sizeof(VkDrawIndexedIndirectCommand),
GPUBufferUsage::IndirectBuffer | GPUBufferUsage::StorageBuffer),
backend.vma_instance);
Assert(MaxIndirectDrawCountPerPass < backend.physicalDeviceProperties.limits.maxDrawIndirectCount);
// FIXME
resources.cull_meshlet_descriptor_sets =
create_descriptor_sets(backend, resources.cullMeshletPipe.descSetLayout, 4);
resources.cull_prepare_descriptor_set =
create_descriptor_sets(backend, resources.cullMeshletPrepIndirect.descSetLayout, 1).front();
resources.cull_triangles_descriptor_sets =
create_descriptor_sets(backend, resources.cullTrianglesPipe.descSetLayout, 4);
const VkEventCreateInfo event_info = {
VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
nullptr,
VK_FLAGS_NONE,
};
Assert(vkCreateEvent(backend.device, &event_info, nullptr, &resources.countersReadyEvent) == VK_SUCCESS);
VulkanSetDebugName(backend.device, resources.countersReadyEvent, "Counters ready event");
return resources;
}
namespace
{
void destroy_simple_pipeline(VkDevice device, SimplePipeline simple_pipeline)
{
vkDestroyPipeline(device, simple_pipeline.pipeline, nullptr);
vkDestroyPipelineLayout(device, simple_pipeline.pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, simple_pipeline.descSetLayout, nullptr);
}
} // namespace
void destroy_culling_resources(VulkanBackend& backend, CullResources& resources)
{
vmaDestroyBuffer(backend.vma_instance, resources.countersBuffer.handle, resources.countersBuffer.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.countersBufferCPU.handle, resources.countersBufferCPU.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.cullInstanceParamsBuffer.handle,
resources.cullInstanceParamsBuffer.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.dynamicIndexBuffer.handle,
resources.dynamicIndexBuffer.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.indirectDispatchBuffer.handle,
resources.indirectDispatchBuffer.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.dynamicMeshletBuffer.handle,
resources.dynamicMeshletBuffer.allocation);
vmaDestroyBuffer(backend.vma_instance, resources.indirectDrawBuffer.handle,
resources.indirectDrawBuffer.allocation);
destroy_simple_pipeline(backend.device, resources.cullMeshletPipe);
destroy_simple_pipeline(backend.device, resources.cullMeshletPrepIndirect);
destroy_simple_pipeline(backend.device, resources.cullTrianglesPipe);
vkDestroyEvent(backend.device, resources.countersReadyEvent, nullptr);
}
void upload_culling_resources(VulkanBackend& backend, const PreparedData& prepared, CullResources& resources)
{
REAPER_PROFILE_SCOPE_FUNC();
if (prepared.cull_mesh_instance_params.empty())
return;
upload_buffer_data(backend.device, backend.vma_instance, resources.cullInstanceParamsBuffer,
prepared.cull_mesh_instance_params.data(),
prepared.cull_mesh_instance_params.size() * sizeof(CullMeshInstanceParams));
}
void update_culling_pass_descriptor_sets(VulkanBackend& backend, const PreparedData& prepared, CullResources& resources,
const MeshCache& mesh_cache)
{
for (const CullPassData& cull_pass : prepared.cull_passes)
{
Assert(cull_pass.pass_index < MaxCullPassCount);
update_cull_meshlet_descriptor_sets(backend, resources, mesh_cache.meshletBuffer, cull_pass.pass_index);
update_culling_descriptor_sets(backend, resources, mesh_cache.indexBuffer, mesh_cache.vertexBufferPosition,
cull_pass.pass_index);
}
update_cull_prepare_indirect_descriptor_set(backend, resources, resources.cull_prepare_descriptor_set);
}
void record_culling_command_buffer(ReaperRoot& root, CommandBuffer& cmdBuffer, const PreparedData& prepared,
CullResources& resources)
{
u64 total_meshlet_count = 0;
std::vector<u64> meshlet_count_per_pass;
const u32 clear_value = 0;
vkCmdFillBuffer(cmdBuffer.handle, resources.countersBuffer.handle, 0, VK_WHOLE_SIZE, clear_value);
{
REAPER_GPU_SCOPE_COLOR(cmdBuffer, "Barrier", MP_RED);
const GPUMemoryAccess src = {VK_PIPELINE_STAGE_2_CLEAR_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT};
const GPUMemoryAccess dst = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT,
VK_ACCESS_2_SHADER_WRITE_BIT | VK_ACCESS_2_SHADER_READ_BIT};
const VkMemoryBarrier2 memoryBarrier = get_vk_memory_barrier(src, dst);
const VkDependencyInfo dependencies = get_vk_memory_barrier_depency_info(1, &memoryBarrier);
vkCmdPipelineBarrier2(cmdBuffer.handle, &dependencies);
}
{
VulkanDebugLabelCmdBufferScope s(cmdBuffer.handle, "Cull Meshes");
vkCmdBindPipeline(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE, resources.cullMeshletPipe.pipeline);
for (const CullPassData& cull_pass : prepared.cull_passes)
{
u64& pass_meshlet_count = meshlet_count_per_pass.emplace_back();
pass_meshlet_count = 0;
vkCmdBindDescriptorSets(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE,
resources.cullMeshletPipe.pipelineLayout, 0, 1,
&resources.cull_meshlet_descriptor_sets[cull_pass.pass_index], 0, nullptr);
for (const CullCmd& command : cull_pass.cull_commands)
{
vkCmdPushConstants(cmdBuffer.handle, resources.cullMeshletPipe.pipelineLayout,
VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(command.push_constants),
&command.push_constants);
const u32 group_count_x = div_round_up(command.push_constants.meshlet_count, MeshletCullThreadCount);
vkCmdDispatch(cmdBuffer.handle, group_count_x, command.instance_count, 1);
pass_meshlet_count += command.push_constants.meshlet_count;
}
total_meshlet_count += pass_meshlet_count;
}
}
{
REAPER_GPU_SCOPE_COLOR(cmdBuffer, "Barrier", MP_RED);
const GPUMemoryAccess src = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT};
const GPUMemoryAccess dst = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT};
const VkMemoryBarrier2 memoryBarrier = get_vk_memory_barrier(src, dst);
const VkDependencyInfo dependencies = get_vk_memory_barrier_depency_info(1, &memoryBarrier);
vkCmdPipelineBarrier2(cmdBuffer.handle, &dependencies);
}
{
VulkanDebugLabelCmdBufferScope s(cmdBuffer.handle, "Indirect Prepare");
vkCmdBindPipeline(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE, resources.cullMeshletPrepIndirect.pipeline);
vkCmdBindDescriptorSets(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE,
resources.cullMeshletPrepIndirect.pipelineLayout, 0, 1,
&resources.cull_prepare_descriptor_set, 0, nullptr);
const u32 group_count_x = div_round_up(prepared.cull_passes.size(), PrepareIndirectDispatchThreadCount);
vkCmdDispatch(cmdBuffer.handle, group_count_x, 1, 1);
}
{
REAPER_GPU_SCOPE_COLOR(cmdBuffer, "Barrier", MP_RED);
const GPUMemoryAccess src = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT};
const GPUMemoryAccess dst = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT};
const VkMemoryBarrier2 memoryBarrier = get_vk_memory_barrier(src, dst);
const VkDependencyInfo dependencies = get_vk_memory_barrier_depency_info(1, &memoryBarrier);
vkCmdPipelineBarrier2(cmdBuffer.handle, &dependencies);
}
{
VulkanDebugLabelCmdBufferScope s(cmdBuffer.handle, "Cull Triangles");
vkCmdBindPipeline(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE, resources.cullTrianglesPipe.pipeline);
for (const CullPassData& cull_pass : prepared.cull_passes)
{
vkCmdBindDescriptorSets(cmdBuffer.handle, VK_PIPELINE_BIND_POINT_COMPUTE,
resources.cullTrianglesPipe.pipelineLayout, 0, 1,
&resources.cull_triangles_descriptor_sets[cull_pass.pass_index], 0, nullptr);
CullPushConstants consts;
consts.output_size_ts = cull_pass.output_size_ts;
vkCmdPushConstants(cmdBuffer.handle, resources.cullTrianglesPipe.pipelineLayout,
VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(consts), &consts);
vkCmdDispatchIndirect(cmdBuffer.handle, resources.indirectDispatchBuffer.handle,
cull_pass.pass_index * sizeof(VkDispatchIndirectCommand));
}
}
{
REAPER_GPU_SCOPE_COLOR(cmdBuffer, "Barrier", MP_RED);
const GPUMemoryAccess src = {VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT};
const GPUMemoryAccess dst = {VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,
VK_ACCESS_2_INDEX_READ_BIT | VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT};
const VkMemoryBarrier2 memoryBarrier = get_vk_memory_barrier(src, dst);
const VkDependencyInfo dependencies = get_vk_memory_barrier_depency_info(1, &memoryBarrier);
vkCmdPipelineBarrier2(cmdBuffer.handle, &dependencies);
}
{
REAPER_GPU_SCOPE(cmdBuffer, "Copy counters");
VkBufferCopy2 region = {};
region.sType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
region.pNext = nullptr;
region.srcOffset = 0;
region.dstOffset = 0;
region.size =
resources.countersBuffer.properties.element_count * resources.countersBuffer.properties.element_size_bytes;
const VkCopyBufferInfo2 copy = {VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, nullptr, resources.countersBuffer.handle,
resources.countersBufferCPU.handle, 1, ®ion};
vkCmdCopyBuffer2(cmdBuffer.handle, ©);
vkCmdResetEvent2(cmdBuffer.handle, resources.countersReadyEvent, VK_PIPELINE_STAGE_2_TRANSFER_BIT);
const GPUResourceAccess src = {VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT};
const GPUResourceAccess dst = {VK_PIPELINE_STAGE_2_HOST_BIT, VK_ACCESS_2_HOST_READ_BIT};
const GPUBufferView view = default_buffer_view(resources.countersBufferCPU.properties);
VkBufferMemoryBarrier2 bufferBarrier =
get_vk_buffer_barrier(resources.countersBufferCPU.handle, view, src, dst);
const VkDependencyInfo dependencies = VkDependencyInfo{
VK_STRUCTURE_TYPE_DEPENDENCY_INFO, nullptr, VK_FLAGS_NONE, 0, nullptr, 1, &bufferBarrier, 0, nullptr};
vkCmdSetEvent2(cmdBuffer.handle, resources.countersReadyEvent, &dependencies);
}
log_debug(root, "CPU mesh stats:");
for (auto meshlet_count : meshlet_count_per_pass)
{
log_debug(root, "- pass total submitted meshlets = {}, approx. triangles = {}", meshlet_count,
meshlet_count * MeshletMaxTriangleCount);
}
log_debug(root, "- total submitted meshlets = {}, approx. triangles = {}", total_meshlet_count,
total_meshlet_count * MeshletMaxTriangleCount);
}
std::vector<CullingStats> get_gpu_culling_stats(VulkanBackend& backend, const PreparedData& prepared,
CullResources& resources)
{
VmaAllocationInfo allocation_info;
vmaGetAllocationInfo(backend.vma_instance, resources.countersBufferCPU.allocation, &allocation_info);
void* mapped_data_ptr = nullptr;
Assert(vkMapMemory(backend.device, allocation_info.deviceMemory, allocation_info.offset, allocation_info.size, 0,
&mapped_data_ptr)
== VK_SUCCESS);
VkMappedMemoryRange staging_range = {};
staging_range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
staging_range.memory = allocation_info.deviceMemory;
staging_range.offset = allocation_info.offset;
staging_range.size = VK_WHOLE_SIZE;
vkInvalidateMappedMemoryRanges(backend.device, 1, &staging_range);
Assert(mapped_data_ptr);
std::vector<CullingStats> stats;
for (u32 i = 0; i < prepared.cull_passes.size(); i++)
{
CullingStats& s = stats.emplace_back();
s.pass_index = i;
s.surviving_meshlet_count = static_cast<u32*>(mapped_data_ptr)[i * CountersCount + MeshletCounterOffset];
s.surviving_triangle_count = static_cast<u32*>(mapped_data_ptr)[i * CountersCount + TriangleCounterOffset];
s.indirect_draw_command_count =
static_cast<u32*>(mapped_data_ptr)[i * CountersCount + DrawCommandCounterOffset];
}
vkUnmapMemory(backend.device, allocation_info.deviceMemory);
return stats;
}
namespace
{
constexpr VkIndexType get_vk_culling_index_type()
{
if constexpr (IndexSizeBytes == 2)
return VK_INDEX_TYPE_UINT16;
else
{
static_assert(IndexSizeBytes == 4, "Invalid index size");
return VK_INDEX_TYPE_UINT32;
}
}
} // namespace
CullingDrawParams get_culling_draw_params(u32 pass_index)
{
CullingDrawParams params;
params.counter_buffer_offset = (pass_index * CountersCount + DrawCommandCounterOffset) * sizeof(u32);
params.index_buffer_offset = pass_index * DynamicIndexBufferSizeBytes;
params.index_type = get_vk_culling_index_type();
params.command_buffer_offset = pass_index * MaxIndirectDrawCountPerPass * sizeof(VkDrawIndexedIndirectCommand);
params.command_buffer_max_count = MaxIndirectDrawCountPerPass;
return params;
}
} // namespace Reaper
| 52.16 | 120 | 0.659482 | Ryp |
47116d2b7b8cf557348c96fd02077b17a2dfac8f | 328 | hpp | C++ | test/base_test.hpp | mexicowilly/Espadin | f33580d2c77c5efe92c05de0816ec194e87906f0 | [
"Apache-2.0"
] | null | null | null | test/base_test.hpp | mexicowilly/Espadin | f33580d2c77c5efe92c05de0816ec194e87906f0 | [
"Apache-2.0"
] | null | null | null | test/base_test.hpp | mexicowilly/Espadin | f33580d2c77c5efe92c05de0816ec194e87906f0 | [
"Apache-2.0"
] | null | null | null | #if !defined(ESPADIN_BASE_TEST_HPP_)
#define ESPADIN_BASE_TEST_HPP_
#include <espadin/drive.hpp>
namespace espadin::test
{
class base
{
protected:
static std::string parent_id;
base();
std::string create_doc(const std::string& name);
void trash(const std::string& file_id);
drive drive_;
};
}
#endif
| 13.12 | 52 | 0.70122 | mexicowilly |
4711822041e1091974e0f4c4b595f619fa91a359 | 194 | hh | C++ | ports/games/enigma/dragonfly/patch-src__file.hh | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 31 | 2015-02-06T17:06:37.000Z | 2022-03-08T19:53:28.000Z | ports/games/enigma/dragonfly/patch-src__file.hh | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 236 | 2015-06-29T19:51:17.000Z | 2021-12-16T22:46:38.000Z | ports/games/enigma/dragonfly/patch-src__file.hh | liweitianux/DeltaPorts | b907de0ceb9c0e46ae8961896e97b361aa7c62c0 | [
"BSD-2-Clause-FreeBSD"
] | 52 | 2015-02-06T17:05:36.000Z | 2021-10-21T12:13:06.000Z | --- src/file.hh.orig 2007-09-08 15:20:02.000000000 +0300
+++ src/file.hh
@@ -21,6 +21,7 @@
#include <iosfwd>
#include <vector>
+#include <memory>
#include <list>
#include "ecl_error.hh"
| 17.636364 | 56 | 0.634021 | liweitianux |
4719a37fc250e61a70c06359c27b9d35b8503218 | 3,507 | cpp | C++ | sp/main.cpp | afmenez/xfspp | 202c8b819d6fe9e1a669f6042e9724ad7415cedd | [
"MIT"
] | 25 | 2017-03-30T04:58:10.000Z | 2022-01-26T22:34:03.000Z | sp/main.cpp | afmenez/xfspp | 202c8b819d6fe9e1a669f6042e9724ad7415cedd | [
"MIT"
] | 4 | 2019-08-26T06:14:47.000Z | 2022-02-23T18:48:11.000Z | sp/main.cpp | afmenez/xfspp | 202c8b819d6fe9e1a669f6042e9724ad7415cedd | [
"MIT"
] | 10 | 2017-04-10T09:52:58.000Z | 2021-09-30T13:42:22.000Z | /* sp/main.cpp
*
* Copyright (C) 2007 Antonio Di Monaco
*
* This software may be modified and distributed under the terms
* of the MIT license. See the LICENSE file for details.
*/
#include "xfsspi.h"
#include "win32/synch.hpp"
namespace
{
HINSTANCE dllInstance;
HANDLE mutexHandle = NULL;
struct Context
{
} *_ctx = nullptr;
void initializeContext()
{
if (!_ctx)
{
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
if (!_ctx)
_ctx = new Context;
}
}
}
extern "C" HRESULT WINAPI WFPCancelAsyncRequest(HSERVICE hService, REQUESTID RequestID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPClose(HSERVICE hService, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPDeregister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPExecute(HSERVICE hService, DWORD dwCommand, LPVOID lpCmdData, DWORD dwTimeOut, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPGetInfo(HSERVICE hService, DWORD dwCategory, LPVOID lpQueryDetails, DWORD dwTimeOut, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPLock(HSERVICE hService, DWORD dwTimeOut, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPOpen(HSERVICE hService, LPSTR lpszLogicalName, HAPP hApp, LPSTR lpszAppID, DWORD dwTraceLevel, DWORD dwTimeOut, HWND hWnd, REQUESTID ReqID, HPROVIDER hProvider, DWORD dwSPIVersionsRequired, LPWFSVERSION lpSPIVersion, DWORD dwSrvcVersionsRequired, LPWFSVERSION lpSrvcVersion)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPRegister(HSERVICE hService, DWORD dwEventClass, HWND hWndReg, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPSetTraceLevel(HSERVICE hService, DWORD dwTraceLevel)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPUnloadService(void)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" HRESULT WINAPI WFPUnlock(HSERVICE hService, HWND hWnd, REQUESTID ReqID)
{
initializeContext();
Windows::Synch::Locker< HANDLE > lock(mutexHandle);
return WFS_SUCCESS;
}
extern "C" BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
{
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
dllInstance = hinstDLL;
mutexHandle = CreateMutex(NULL,FALSE,NULL);
break;
case DLL_PROCESS_DETACH:
CloseHandle(mutexHandle);
delete _ctx;
break;
default:
break;
}
return TRUE;
}
| 22.921569 | 304 | 0.697177 | afmenez |
4719ffba36ee3ce93b51efffee4973d79e571aaa | 729 | cpp | C++ | workspace/hellotest/src/Test.cpp | PeterSommerlad/workshopworkspace | 5e5eb9c42280a4aba27ee196d3003fd54a5e3607 | [
"MIT"
] | 2 | 2021-08-28T11:43:58.000Z | 2021-09-07T08:10:05.000Z | workspace/hellotest/src/Test.cpp | PeterSommerlad/workshopworkspace | 5e5eb9c42280a4aba27ee196d3003fd54a5e3607 | [
"MIT"
] | null | null | null | workspace/hellotest/src/Test.cpp | PeterSommerlad/workshopworkspace | 5e5eb9c42280a4aba27ee196d3003fd54a5e3607 | [
"MIT"
] | null | null | null | #include "sayhello.h"
#include "cute.h"
#include "ide_listener.h"
#include "xml_listener.h"
#include "cute_runner.h"
#include <sstream>
void createDefaultCounterIsZero() {
std::ostringstream out{};
sayhello(out);
ASSERT_EQUAL("Hello, World\n",out.str());
}
bool runAllTests(int argc, char const *argv[]) {
cute::suite s { };
//TODO add your test here
s.push_back(CUTE(createDefaultCounterIsZero));
cute::xml_file_opener xmlfile(argc, argv);
cute::xml_listener<cute::ide_listener<>> lis(xmlfile.out);
auto runner = cute::makeRunner(lis, argc, argv);
bool success = runner(s, "AllTests");
return success;
}
int main(int argc, char const *argv[]) {
return runAllTests(argc, argv) ? EXIT_SUCCESS : EXIT_FAILURE;
}
| 25.137931 | 65 | 0.717421 | PeterSommerlad |
471aec311c77dbf71682cd75097f37b16465dd65 | 516 | hpp | C++ | dfu-module/include/dfu_main.hpp | jetbeep/libjetbeep-usb | 4fc083dfec9873f435a460f8e3f43c582620d290 | [
"MIT"
] | 5 | 2019-11-29T04:43:32.000Z | 2020-06-12T13:59:44.000Z | dfu-module/include/dfu_main.hpp | jetbeep/libjetbeep-usb | 4fc083dfec9873f435a460f8e3f43c582620d290 | [
"MIT"
] | null | null | null | dfu-module/include/dfu_main.hpp | jetbeep/libjetbeep-usb | 4fc083dfec9873f435a460f8e3f43c582620d290 | [
"MIT"
] | null | null | null | #ifndef DFU_MAIN__HPP
#define DFU_MAIN__HPP
#include "../lib/libjetbeep.hpp"
using namespace std;
enum class DeviceBootState { APP, BOOTLOADER, UNKNOWN };
enum class DeviceConfigState { CONFIGURED, PARTIAL, BLANK, UNKNOWN };
struct DeviceInfo {
DeviceBootState bootState = DeviceBootState::UNKNOWN;
DeviceConfigState configState = DeviceConfigState::UNKNOWN;
uint32_t deviceId;
string pubKey;
string version;
string revision;
string chipId;
string systemPath;
bool nativeUSBSupport;
};
#endif | 21.5 | 69 | 0.773256 | jetbeep |
471b742daaa0fe045f51c979d75f9abb055dd52b | 4,937 | cpp | C++ | codeforces/DIV3_629/e.cpp | Shahraaz/CP_S5 | 2cfb5467841d660c1e47cb8338ea692f10ca6e60 | [
"MIT"
] | 3 | 2020-02-08T10:34:16.000Z | 2020-02-09T10:23:19.000Z | codeforces/DIV3_629/e.cpp | Shahraaz/CP_S5 | 2cfb5467841d660c1e47cb8338ea692f10ca6e60 | [
"MIT"
] | null | null | null | codeforces/DIV3_629/e.cpp | Shahraaz/CP_S5 | 2cfb5467841d660c1e47cb8338ea692f10ca6e60 | [
"MIT"
] | 2 | 2020-10-02T19:05:32.000Z | 2021-09-08T07:01:49.000Z | // Optimise
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// #define MULTI_TEST
#ifdef LOCAL
#include "/home/shahraaz/bin/debug.h"
#else
#define db(...)
#define pc(...)
#endif
#define f first
#define s second
#define pb push_back
#define all(v) v.begin(), v.end()
auto TimeStart = chrono::steady_clock::now();
auto seed = TimeStart.time_since_epoch().count();
std::mt19937 rng(seed);
using ll = long long;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using Random = std::uniform_int_distribution<T>;
const int NAX = 2e5 + 5, MOD = 1000000007;
vector<vector<int>> adj;
int depth[NAX], par[NAX];
//Here it is an unweighted tree
//If you want to solve for thath then
//You have to go for Dist(a,b) = Dist(a) + Dist(b) - 2*Dist(lca(a,b))
// where Dist(a) is distance from Root to a;
struct LeastCommonAncestor
{
vector<int> Level;
vector<vector<int>> dp;
vector<vector<int>> Adj;
int Log;
LeastCommonAncestor() {}
LeastCommonAncestor(vector<vector<int>> &Tree) : Adj(Tree)
{
int n = Tree.size();
Log = ceil(log2(n)) + 1;
dp.assign(Log, vector<int>(n));
Level.assign(n, 0);
dfs(0, 0, 0);
for (int i = 1; i < Log; ++i)
for (int j = 0; j < n; ++j)
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
void dfs(int node, int parent, int level)
{
dp[0][node] = parent;
Level[node] = level;
for (auto child : Adj[node])
if (child != parent)
dfs(child, node, level + 1);
}
int lca(int a, int b)
{
if (Level[a] > Level[b])
swap(a, b);
int d = Level[b] - Level[a];
for (int i = 0; i < Log; ++i)
if (d & (1 << i))
b = dp[i][b];
if (a == b)
return a;
for (int i = Log - 1; i >= 0; --i)
if (dp[i][a] != dp[i][b])
{
a = dp[i][a];
b = dp[i][b];
}
return dp[0][a];
}
int dist(int a, int b)
{
return Level[a] + Level[b] - 2 * Level[lca(a, b)];
}
};
bool cmp(int u, int v)
{
return depth[u] > depth[v];
}
class Solution
{
private:
void dfs(int node, int par, int depth = 0)
{
db(node, par, depth);
::par[node] = par;
::depth[node] = depth;
for (auto &child : adj[node])
if (child != par)
dfs(child, node, depth + 1);
}
public:
Solution() {}
~Solution() {}
void solveCase()
{
int n, m;
cin >> n >> m;
adj.resize(n);
for (size_t i = 1; i < n; i++)
{
int u, v;
cin >> u >> v;
--u, --v;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(0, -1);
LeastCommonAncestor lca(adj);
for (size_t i = 0; i < m; i++)
{
int k;
cin >> k;
vector<int> v(k);
for (auto &x : v)
{
cin >> x;
--x;
}
sort(all(v), cmp);
pc(v);
int curr = v[0];
bool ok = true;
for (size_t i = 1; i < k; i++)
{
db(curr, v[i], depth[curr], depth[v[i]]);
if (depth[curr] == depth[v[i]])
{
if (par[curr] == par[v[i]])
{
;
}
else
{
ok = false;
break;
}
}
else if (depth[curr] > depth[v[i]])
{
int pparNode = lca.lca(curr, v[i]);
if (v[i] == pparNode || par[v[i]] == pparNode)
{
}
else
{
ok = false;
break;
}
curr = pparNode;
}
else
{
ok = false;
break;
}
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
}
};
int32_t main()
{
#ifndef LOCAL
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int t = 1;
#ifdef MULTI_TEST
cin >> t;
#endif
Solution mySolver;
for (int i = 1; i <= t; ++i)
{
mySolver.solveCase();
#ifdef TIME
cerr << "Case #" << i << ": Time " << chrono::duration<double>(chrono::steady_clock::now() - TimeStart).count() << " s.\n";
TimeStart = chrono::steady_clock::now();
#endif
}
return 0;
} | 24.685 | 131 | 0.421916 | Shahraaz |
471c640c252c83a002cdd3f0356636abcac55d67 | 607 | cpp | C++ | cozybirdFX/UIIntField.cpp | HenryLoo/cozybirdFX | 0ef522d9a8304c190c8a586a4de6452c6bc9edfe | [
"BSD-3-Clause"
] | null | null | null | cozybirdFX/UIIntField.cpp | HenryLoo/cozybirdFX | 0ef522d9a8304c190c8a586a4de6452c6bc9edfe | [
"BSD-3-Clause"
] | null | null | null | cozybirdFX/UIIntField.cpp | HenryLoo/cozybirdFX | 0ef522d9a8304c190c8a586a4de6452c6bc9edfe | [
"BSD-3-Clause"
] | null | null | null | #include "UIIntField.h"
UIIntField::UIIntField(std::string label, int maxChars, glm::vec2 size,
glm::vec2 position) :
UIField(label, maxChars, size, position)
{
}
void UIIntField::setValue(int value)
{
UIField::setValue(std::to_string(value));
}
bool UIIntField::getValue(int &output)
{
try
{
output = std::stoi(m_value);
return isNewValue();
}
catch (std::exception &)
{
return false;
}
}
bool UIIntField::formatValue()
{
try
{
int val{ m_value.empty() ? 0 : std::stoi(m_value) };
m_value = std::to_string(val);
return true;
}
catch (std::exception &)
{
return false;
}
}
| 15.175 | 72 | 0.662273 | HenryLoo |
472066a3ebce89d661fa1cc0c86601d26704832e | 15,311 | cpp | C++ | darkroom/src/TrackedObject.cpp | Roboy/roboy_darkroom | ed9572dc92f27c8b40265a1d3369bf270e1fbc30 | [
"BSD-3-Clause"
] | 11 | 2018-03-10T04:32:11.000Z | 2022-02-10T10:55:44.000Z | darkroom/src/TrackedObject.cpp | Roboy/roboy_darkroom | ed9572dc92f27c8b40265a1d3369bf270e1fbc30 | [
"BSD-3-Clause"
] | null | null | null | darkroom/src/TrackedObject.cpp | Roboy/roboy_darkroom | ed9572dc92f27c8b40265a1d3369bf270e1fbc30 | [
"BSD-3-Clause"
] | 1 | 2019-05-04T09:51:01.000Z | 2019-05-04T09:51:01.000Z | #include "darkroom/TrackedObject.hpp"
int LighthouseEstimator::trackedObjectInstance = 0;
bool TrackedObject::m_switch = false;
TrackedObject::TrackedObject(ros::NodeHandlePtr nh):RobotLocalization::RosEkf(*nh,*nh), nh(nh) {
darkroom_statistics_pub = nh->advertise<roboy_middleware_msgs::DarkRoomStatistics>(
"/roboy/middleware/DarkRoom/Statistics", 1);
receiveData = true;
sensor_sub = nh->subscribe("/roboy/middleware/DarkRoom/sensors", 2, &TrackedObject::receiveSensorDataRoboy, this);
spinner = boost::shared_ptr<ros::AsyncSpinner>(new ros::AsyncSpinner(2));
spinner->start();
string package_path = ros::package::getPath("darkroom");
string calibration_path = package_path + "/params/lighthouse_calibration.yaml";
readCalibrationConfig(calibration_path,LIGHTHOUSE_A,calibration[LIGHTHOUSE_A]);
readCalibrationConfig(calibration_path,LIGHTHOUSE_B,calibration[LIGHTHOUSE_B]);
path = package_path+"/calibrated_objects";
pose.setOrigin(tf::Vector3(0,0,0));
pose.setRotation(tf::Quaternion(0,0,0,1));
string load_yaml_command = "rosparam load "+package_path+"/params/ekf_parameters.yaml " + nh->getNamespace();
ROS_DEBUG_STREAM("loading yaml file using this command: " << load_yaml_command);
system(load_yaml_command.c_str());
trackedObjectInstance++;
}
TrackedObject::~TrackedObject() {
shutDown();
// delete all remaining markers
clearAll();
}
bool TrackedObject::init(const char* configFile){
ROS_INFO_STREAM("reading config of " << configFile);
if(!readConfig(configFile, objectID, name, mesh, calibrated_sensors, sensors, calibration_angles))
return false;
for(auto &sensor:sensors){
Vector3d rel_pos;
sensor.second.getRelativeLocation(rel_pos);
publishSphere(rel_pos,"world","relative_locations",rand(),COLOR(0,1,0,1),0.01,10);
}
imu.setOrigin(tf::Vector3(0,0,0));
imu.setRotation(tf::Quaternion(0,0,0,1));
// some object specific parameters are set here:
// nh->setParam("map_frame", "odom");
// nh->setParam("world_frame", "world");
nh->setParam("base_link_frame", name);
// nh->setParam("odom_frame", "odom");
// std::replace(name.begin(),name.end(),"-","_");
imu_topic_name = "roboy/middleware/"+name+"/imu";
pose_topic_name = "roboy/middleware/"+name+"/pose";
nh->setParam("imu0", imu_topic_name);
nh->setParam("pose0", pose_topic_name);
// nh->setParam("publish_tf", true);
nh->setParam("print_diagnostics", true);
// vector<float> process_noise_covariance = {
// 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0.06, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0.03, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0.03, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0.06, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0.025, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0.025, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0.04, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.01, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.01, 0, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.02, 0, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.01, 0, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.01, 0,
// 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.015
// };
// nh->setParam("process_noise_covariance", process_noise_covariance);
// vector<bool> activeStatesIMU = {false, false, false, // XYZ
// true, true, true, // roll, pitch, yaw
// false, false, false, // d(XYZ)
// false, false, false, // d(roll, pitch, yaw)
// true, true, true // dd(XYZ)
// };
// nh->setParam("imu0_config", activeStatesIMU);
// nh->setParam("imu0_queue_size", 100);
// nh->setParam("imu0_differential", false);
// nh->setParam("imu0_relative", true);
// nh->setParam("imu0_remove_gravitational_acceleration", false);
// nh->setParam("pose0", nh->getNamespace()+"/pose0");
// vector<bool> activeStatesPose = {true, true, true, // XYZ
// true, true, true, // roll, pitch, yaw
// false, false, false, // d(XYZ)
// false, false, false, // d(roll, pitch, yaw)
// false, false, false // dd(XYZ)
// };
// nh->setParam("pose0_config", activeStatesPose);
// nh->setParam("pose0_queue_size", 100);
// nh->setParam("pose0_differential", false);
// nh->setParam("pose0_relative", true);
//
vector<float> initial_state = { 0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0
};
nh->setParam("initial_state", initial_state);
// nh->setParam("publish_tf", true);
// nh->setParam("print_diagnostics", true);
// // start extended kalman filter
// kalman_filter_thread.reset(new boost::thread(&TrackedObject::run, this));
return true;
}
void TrackedObject::shutDown(){
mux.lock();
receiveData = false;
tracking = false;
calibrating = false;
poseestimating = false;
poseestimating_epnp = false;
poseestimating_multiLighthouse = false;
receiveData = false;
publish_transform = false;
rays = false;
if (sensor_thread != nullptr) {
if (sensor_thread->joinable()) {
ROS_INFO("Waiting for sensor thread to terminate");
sensor_thread->join();
}
}
if (tracking_thread != nullptr) {
if (tracking_thread->joinable()) {
ROS_INFO("Waiting for tracking thread to terminate");
tracking_thread->join();
}
}
if (rays_thread != nullptr) {
if (rays_thread->joinable()) {
ROS_INFO("Waiting for rays thread to terminate");
rays_thread->join();
}
}
if (calibrate_thread != nullptr) {
if (calibrate_thread->joinable()) {
ROS_INFO("Waiting for calibration thread to terminate");
calibrate_thread->join();
}
}
if (poseestimation_thread != nullptr) {
if (poseestimation_thread->joinable()) {
ROS_INFO("Waiting for pose estimation thread to terminate");
poseestimation_thread->join();
}
}
if (relative_pose_epnp_thread != nullptr) {
if (relative_pose_epnp_thread->joinable()) {
ROS_INFO("Waiting for pose estimation epnp thread to terminate");
relative_pose_epnp_thread->join();
}
}
if (object_pose_estimation_multi_lighthouse_thread != nullptr) {
if (object_pose_estimation_multi_lighthouse_thread->joinable()) {
ROS_INFO("Waiting for pose estimation multi lighthouse thread to terminate");
object_pose_estimation_multi_lighthouse_thread->join();
}
}
if (publish_imu_transform != nullptr) {
if (publish_imu_transform->joinable()) {
ROS_INFO("Waiting for imu publish thread to terminate");
publish_imu_transform->join();
}
}
mux.unlock();
}
void TrackedObject::connectObject(const char* broadcastIP, int port){
uint32_t ip;
inet_pton(AF_INET, broadcastIP, &ip);
socket = UDPSocketPtr(new UDPSocket(port, ip, false));
mux.lock();
receiveData = true;
sensor_thread = boost::shared_ptr<boost::thread>(new boost::thread(&TrackedObject::receiveSensorData, this));
sensor_thread->detach();
mux.unlock();
}
void TrackedObject::switchLighthouses(bool switchID) {
ROS_INFO_STREAM("switching lighthouses " << switchID);
m_switch = switchID;
for (auto &sensor : sensors) {
sensor.second.switchLighthouses(switchID);
}
}
bool TrackedObject::record(bool start) {
if (start) {
char str[100];
sprintf(str, "record_%s.log", name.c_str());
file.open(str);
if (file.is_open()) {
ROS_INFO("start recording");
file << "timestamp, \tid, \tlighthouse, \trotor, \tsweepDuration[ticks], \tangle[rad]\n";
recording = true;
return true;
} else {
ROS_ERROR("could not open file");
return false;
}
} else {
ROS_INFO("saving to file recording");
recording = false;
file.close();
return true;
}
}
void TrackedObject::receiveSensorDataRoboy(const roboy_middleware_msgs::DarkRoom::ConstPtr &msg) {
if(msg->object_id != objectID){
// only use messages for me
ROS_DEBUG_STREAM_THROTTLE(1,"receiving sensor data, but it's not for me " << objectID << " " << msg->object_id);
return;
}
ROS_WARN_THROTTLE(10, "receiving sensor data");
uint id = 0;
static int message_counter = 0;
uint lighthouse, rotor, sensorID,sweepDuration;
for (uint32_t const &data:msg->sensor_value) {
lighthouse = (data >> 31) & 0x1;
rotor = (data >> 30) & 0x1;
int valid = (data >> 29) & 0x1;
sensorID= ((data >>19) & 0x3FF);
sweepDuration= ((data & 0x7FFFF));
// ROS_INFO_STREAM_THROTTLE(1,
// "valid: " << valid << endl <<
// "sensorID: " << sensorID << endl <<
// "lighthouse: " << lighthouse << endl <<
// "rotor: " << rotor << endl <<
// "sweepDuration: " << sweepDuration << endl <<
// "angle: " << ticksToRadians(sweepDuration));
if (valid == 1) {
double angle = ticksToRadians(sweepDuration);
sensors[sensorID].update(lighthouse, rotor, angle);
if (recording) {
mux.lock();
file << msg->timestamp[sensorID] << ",\t" << sensorID << ",\t"
<< lighthouse << ",\t" << rotor << ",\t" << sweepDuration << ",\t" << angle << endl;
mux.unlock();
}
}
id++;
}
if(message_counter++%50==0){ // publish statistics from time to time
{
roboy_middleware_msgs::DarkRoomStatistics statistics_msg;
statistics_msg.object_name = name;
statistics_msg.lighthouse = LIGHTHOUSE_A;
for (uint i = 0; i < msg->sensor_value.size(); i++) {
float horizontal, vertical;
sensors[i].updateFrequency(LIGHTHOUSE_A, horizontal, vertical);
statistics_msg.update_frequency_horizontal.push_back(horizontal);
statistics_msg.update_frequency_vertical.push_back(vertical);
}
darkroom_statistics_pub.publish(statistics_msg);
}
{
roboy_middleware_msgs::DarkRoomStatistics statistics_msg;
statistics_msg.object_name = name;
statistics_msg.lighthouse = LIGHTHOUSE_B;
for (uint i = 0; i < msg->sensor_value.size(); i++) {
float horizontal, vertical;
sensors[i].updateFrequency(LIGHTHOUSE_B, horizontal, vertical);
statistics_msg.update_frequency_horizontal.push_back(horizontal);
statistics_msg.update_frequency_vertical.push_back(vertical);
}
darkroom_statistics_pub.publish(statistics_msg);
}
}
}
void TrackedObject::receiveSensorData(){
chrono::high_resolution_clock::time_point t0 = chrono::high_resolution_clock::now();
int message_counter = 0;
while(receiveData){
vector<uint32_t> id;
vector<bool> lighthouse;
vector<bool> rotor;
vector<uint32_t> sweepDuration;
if(socket->receiveSensorData(id,lighthouse,rotor,sweepDuration)){
for(uint i=0; i<id.size(); i++) {
double angle = ticksToRadians(sweepDuration[i]);
ROS_INFO_THROTTLE(10, "id: %d lighthouse: %d rotor: %d sweepDuration: %d angle: %.3f", id[i], lighthouse[i],
rotor[i], sweepDuration[i],ticksToDegrees(sweepDuration[i]));
sensors[id[i]].update(lighthouse[i], rotor[i], angle);
if (recording) {
chrono::high_resolution_clock::time_point t1 = chrono::high_resolution_clock::now();
chrono::microseconds time_span = chrono::duration_cast<chrono::microseconds>(t1 - t0);
mux.lock();
file << time_span.count() << ",\t" << id[i] << ",\t"
<< lighthouse[i] << ",\t" << rotor[i] << ",\t" << sweepDuration[i] << ",\t" << angle << endl;
mux.unlock();
}
}
if(message_counter++%50==0){ // publish statistics from time to time
{
roboy_middleware_msgs::DarkRoomStatistics statistics_msg;
statistics_msg.object_name = name;
statistics_msg.lighthouse = LIGHTHOUSE_A;
for (uint32_t i:id) {
float horizontal, vertical;
sensors[i].updateFrequency(LIGHTHOUSE_A, horizontal, vertical);
statistics_msg.update_frequency_horizontal.push_back(horizontal);
statistics_msg.update_frequency_vertical.push_back(vertical);
}
darkroom_statistics_pub.publish(statistics_msg);
}
{
roboy_middleware_msgs::DarkRoomStatistics statistics_msg;
statistics_msg.object_name = name;
statistics_msg.lighthouse = LIGHTHOUSE_B;
for (uint32_t i:id) {
float horizontal, vertical;
sensors[i].updateFrequency(LIGHTHOUSE_B, horizontal, vertical);
statistics_msg.update_frequency_horizontal.push_back(horizontal);
statistics_msg.update_frequency_vertical.push_back(vertical);
}
darkroom_statistics_pub.publish(statistics_msg);
}
}
}
}
}
void TrackedObject::publishImuFrame(){
ros::Rate rate(30);
while (publish_transform) {
// lock_guard<mutex> lock(mux);
tf_broadcaster.sendTransform(tf::StampedTransform(imu, ros::Time::now(), "world", "odom"));
rate.sleep();
}
} | 42.887955 | 124 | 0.541506 | Roboy |
47254dd68dab3b3ce09b22f1094ff9d2a84e038c | 1,032 | cpp | C++ | Session 2019/DP/Jumps/minjumps.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 13 | 2019-10-12T14:36:32.000Z | 2021-06-08T04:26:30.000Z | Session 2019/DP/Jumps/minjumps.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 1 | 2020-02-29T14:02:39.000Z | 2020-02-29T14:02:39.000Z | Session 2019/DP/Jumps/minjumps.cpp | JanaSabuj/Leetcode-solutions | 78d10926b15252a969df598fbf1f9b69b2760b79 | [
"MIT"
] | 3 | 2020-02-08T12:04:28.000Z | 2020-03-17T11:53:00.000Z | //https://practice.geeksforgeeks.org/problems/minimum-number-of-jumps/0
#include <bits/stdc++.h>
using namespace std;
int t[10000007];
bool gflag = false;
int jumps(const vector<int>& arr, int i, int j, int n){
if(i == j){
gflag = true;
return 0;
}
if(t[i] != -1)
return t[i];
int val = arr[i];
int steps = INT_MAX;
for(int k = 0; k < val and i + k + 1 < n; k++){
if(arr[i + k + 1] == 0 and (i + k + 1)!= n - 1)
continue;
else
steps = min(steps, jumps(arr, i + k + 1, j, n));
}
return t[i] = 1 + steps;
}
int main() {
int test;
cin>>test;
while(test--){
int n;
cin>>n;
vector<int> arr(n);
for(int i = 0; i < n; i++)
cin>>arr[i];
memset(t, -1, sizeof(t));
gflag = false;
int ans = jumps(arr, 0, n - 1, n);
if(gflag)
cout << ans << endl;
else
cout << -1 << endl;
}
return 0;
}
| 19.111111 | 71 | 0.437016 | JanaSabuj |
4726bf017d83ca5a8e1b88c88689f30c3b3585d6 | 381 | cpp | C++ | src/custom/ucrt/common/stdio/fputc.cpp | ntoskrnl7/crtsys | 2948afde9496d4e873dc067d1d0e8a545ce894bc | [
"MIT"
] | null | null | null | src/custom/ucrt/common/stdio/fputc.cpp | ntoskrnl7/crtsys | 2948afde9496d4e873dc067d1d0e8a545ce894bc | [
"MIT"
] | null | null | null | src/custom/ucrt/common/stdio/fputc.cpp | ntoskrnl7/crtsys | 2948afde9496d4e873dc067d1d0e8a545ce894bc | [
"MIT"
] | null | null | null | #include "../../../common/crt/crt_internal.h"
EXTERN_C
int __cdecl fputc(int const c, FILE *const stream) {
if (stream == stdout) {
DbgPrintEx(DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "%c", c);
return c;
} else if (stream == stderr) {
DbgPrintEx(DPFLTR_IHVDRIVER_ID, DPFLTR_ERROR_LEVEL, "%c", c);
return c;
}
// untested :-(
KdBreakPoint();
return 0;
} | 25.4 | 65 | 0.645669 | ntoskrnl7 |
4728461966a6bdc3f46f8f6eefba89e8d41eec6a | 7,013 | cpp | C++ | src/tibb/src/TiTitaniumObject.cpp | ssaracut/titanium_mobile_blackberry | 952a8100086dcc625584e33abc2dc03340cbb219 | [
"Apache-2.0"
] | 3 | 2015-03-07T15:41:18.000Z | 2015-11-05T05:07:45.000Z | src/tibb/src/TiTitaniumObject.cpp | ssaracut/titanium_mobile_blackberry | 952a8100086dcc625584e33abc2dc03340cbb219 | [
"Apache-2.0"
] | 1 | 2015-04-12T11:50:33.000Z | 2015-04-12T21:13:19.000Z | src/tibb/src/TiTitaniumObject.cpp | ssaracut/titanium_mobile_blackberry | 952a8100086dcc625584e33abc2dc03340cbb219 | [
"Apache-2.0"
] | 5 | 2015-01-13T17:14:41.000Z | 2015-05-25T16:54:26.000Z | /**
* Appcelerator Titanium Mobile
* Copyright (c) 2009-2012 by Appcelerator, Inc. All Rights Reserved.
* Licensed under the terms of the Apache Public License
* Please see the LICENSE included with this distribution for details.
*/
#include "TiTitaniumObject.h"
#include "TiAccelerometer.h"
#include "TiBufferObject.h"
#include "TiBufferStreamObject.h"
#include "TiCodecObject.h"
#include "TiGenericFunctionObject.h"
#include "TiGesture.h"
#include "TiMessageStrings.h"
#include "TiLocaleObject.h"
#include "TiStreamObject.h"
#include "TiUIObject.h"
#include "TiMap.h"
#include "TiMedia.h"
#include "TiNetwork.h"
#include "TiDatabase.h"
#include "TiAnalyticsObject.h"
#include "TiV8EventContainerFactory.h"
#include "Contacts/ContactsModule.h"
#include <TiCore.h>
#include "V8Utils.h"
#include <fstream>
using namespace titanium;
static const string rootFolder = "app/native/assets/";
TiTitaniumObject::TiTitaniumObject()
: TiProxy("Ti")
{
objectFactory_ = NULL;
}
TiTitaniumObject::~TiTitaniumObject()
{
}
TiObject* TiTitaniumObject::createObject(NativeObjectFactory* objectFactory)
{
TiTitaniumObject* obj = new TiTitaniumObject;
obj->objectFactory_ = objectFactory;
return obj;
}
void TiTitaniumObject::onCreateStaticMembers()
{
TiProxy::onCreateStaticMembers();
ADD_STATIC_TI_VALUE("buildDate", String::New(__DATE__), this);
// TODO: remove hard coded version number
ADD_STATIC_TI_VALUE("version", Number::New(2.0), this);
TiGenericFunctionObject::addGenericFunctionToParent(this, "globalInclude", this, _globalInclude);
TiGenericFunctionObject::addGenericFunctionToParent(this, "createBuffer", this, _createBuffer);
TiUIObject::addObjectToParent(this, objectFactory_);
TiMap::addObjectToParent(this, objectFactory_);
TiMedia::addObjectToParent(this, objectFactory_);
TiCodecObject::addObjectToParent(this);
TiNetwork::addObjectToParent(this, objectFactory_);
TiAnalyticsObject::addObjectToParent(this, objectFactory_);
TiDatabase::addObjectToParent(this, objectFactory_);
TiBufferStreamObject::addObjectToParent(this);
TiStreamObject::addObjectToParent(this);
TiLocaleObject::addObjectToParent(this);
TiGesture::addObjectToParent(this, objectFactory_);
TiAccelerometer::addObjectToParent(this, objectFactory_);
ContactsModule::addObjectToParent(this, objectFactory_);
}
bool TiTitaniumObject::canAddMembers() const
{
// return false;
return true;
}
static Handle<Value> includeJavaScript(string id, string parentFolder, bool* error) {
// CommonJS path rules
if (id.find("/") == 0) {
id.replace(id.find("/"), std::string("/").length(), rootFolder);
}
else if (id.find("./") == 0) {
id.replace(id.find("./"), std::string("./").length(), parentFolder);
}
else if (id.find("../") == 0) {
// count ../../../ in id and strip off back of parentFolder
int count = 0;
size_t idx = 0;
size_t pos = 0;
while (true) {
idx = id.find("../", pos);
if (idx == std::string::npos) {
break;
} else {
pos = idx + 3;
count++;
}
}
// strip leading ../../ off module id
id = id.substr(pos);
// strip paths off the parent folder
idx = 0;
pos = parentFolder.size();
for (int i = 0; i < count; i++) {
idx = parentFolder.find_last_of("/", pos);
pos = idx - 1;
}
if (idx == std::string::npos) {
*error = true;
return ThrowException(String::New("Unable to find module"));
}
parentFolder = parentFolder.substr(0, idx + 1);
id = parentFolder + id;
}
else {
string tempId = rootFolder + id;
ifstream ifs((tempId).c_str());
if (!ifs) {
id = parentFolder + id;
}
else {
id = rootFolder + id;
}
}
string filename = id;
string javascript;
{
ifstream ifs((filename).c_str());
if (!ifs)
{
*error = true;
Local<Value> taggedMessage = String::New((string(Ti::Msg::No_such_native_module) + " " + id).c_str());
return ThrowException(taggedMessage);
}
getline(ifs, javascript, string::traits_type::to_char_type(string::traits_type::eof()));
ifs.close();
}
// wrap the module
{
size_t idx = filename.find_last_of("/");
parentFolder = filename.substr(0, idx + 1);
const char* _parent = parentFolder.c_str();
string preWrap = "Ti.include = function () {"
"var i_args = Array.prototype.slice.call(arguments);"
"for(var i = 0, len = i_args.length; i < len; i++) {"
"Ti.globalInclude([i_args[i]], '" + parentFolder + "');"
"}"
"};";
javascript = preWrap + javascript;
}
TryCatch tryCatch;
Handle<Script> compiledScript = Script::Compile(String::New(javascript.c_str()), String::New(filename.c_str()));
if (compiledScript.IsEmpty())
{
Ti::TiErrorScreen::ShowWithTryCatch(tryCatch);
return Undefined();
}
Local<Value> result = compiledScript->Run();
if (result.IsEmpty())
{
Ti::TiErrorScreen::ShowWithTryCatch(tryCatch);
return Undefined();
}
return result;
}
Handle<Value> TiTitaniumObject::_globalInclude(void*, TiObject*, const Arguments& args)
{
if (!args.Length()) {
return Undefined();
}
bool error = false;
if (args[0]->IsArray()) {
Local<Array> ids = Local<Array>::Cast(args[0]);
uint32_t count = ids->Length();
string parentFolder = *String::Utf8Value(args[1]);
for (uint32_t i = 0; i < count; i++) {
string id = *String::Utf8Value(ids->Get(i));
Handle<Value> result = includeJavaScript(id, parentFolder, &error);
if (error) return result;
}
}
else {
for (uint32_t i = 0; i < args.Length(); i++) {
string id = *String::Utf8Value(args[i]);
Handle<Value> result = includeJavaScript(id, rootFolder, &error);
if (error) return result;
}
}
return Undefined();
}
Handle<Value> TiTitaniumObject::_createBuffer(void* userContext, TiObject*, const Arguments& args)
{
HandleScope handleScope;
TiTitaniumObject* obj = (TiTitaniumObject*) userContext;
Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder());
Handle<Object> result = global->NewInstance();
TiBufferObject* newBuffer = TiBufferObject::createBuffer(obj->objectFactory_);
newBuffer->setValue(result);
if ((args.Length() > 0) && (args[0]->IsObject()))
{
Local<Object> settingsObj = Local<Object>::Cast(args[0]);
newBuffer->setParametersFromObject(newBuffer, settingsObj);
}
setTiObjectToJsObject(result, newBuffer);
return handleScope.Close(result);
}
| 30.491304 | 116 | 0.626551 | ssaracut |
472a25b426aa42adfa5075f692addc5851541aee | 658 | cpp | C++ | contests/Kickstart/2020/Round_B/Bus_Routes/mian.cpp | cristicretu/cplusplus | 87f5980271431b11ae1b8c14ce6d2c620a404488 | [
"MIT"
] | 1 | 2022-01-27T17:13:08.000Z | 2022-01-27T17:13:08.000Z | contests/Kickstart/2020/Round_B/Bus_Routes/mian.cpp | cristicretu/cplusplus | 87f5980271431b11ae1b8c14ce6d2c620a404488 | [
"MIT"
] | null | null | null | contests/Kickstart/2020/Round_B/Bus_Routes/mian.cpp | cristicretu/cplusplus | 87f5980271431b11ae1b8c14ce6d2c620a404488 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
typedef long long ll;
int n;
ll d;
ll v[1001];
inline bool ok(ll mb) {
for (int i = 0; i < n; ++i) {
if (mb % v[i]) {
mb += (v[i] - mb % v[i]);
}
}
return mb <= d;
}
void solve() {
std::cin >> n >> d;
for (int i = 0; i < n; ++i) {
std::cin >> v[i];
}
ll lb = 0, rb = d;
while (lb < rb) {
ll mb = (lb + rb + 1) / 2;
if (ok(mb)) {
lb = mb;
} else {
rb = mb - 1;
}
}
std::cout << lb;
}
int main() {
using namespace std;
int t;
cin >> t;
for (int i = 1; i <= t; ++i) {
cout << "Case #" << i << ": ";
solve();
cout << '\n';
}
return 0;
} | 12.901961 | 34 | 0.390578 | cristicretu |
472a6b5baf59994c83f009a7b64434aab018bc19 | 4,578 | cc | C++ | arms/src/model/ListClusterFromGrafanaResult.cc | iamzken/aliyun-openapi-cpp-sdk | 3c991c9ca949b6003c8f498ce7a672ea88162bf1 | [
"Apache-2.0"
] | 89 | 2018-02-02T03:54:39.000Z | 2021-12-13T01:32:55.000Z | arms/src/model/ListClusterFromGrafanaResult.cc | iamzken/aliyun-openapi-cpp-sdk | 3c991c9ca949b6003c8f498ce7a672ea88162bf1 | [
"Apache-2.0"
] | 89 | 2018-03-14T07:44:54.000Z | 2021-11-26T07:43:25.000Z | arms/src/model/ListClusterFromGrafanaResult.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 69 | 2018-01-22T09:45:52.000Z | 2022-03-28T07:58:38.000Z | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/arms/model/ListClusterFromGrafanaResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ARMS;
using namespace AlibabaCloud::ARMS::Model;
ListClusterFromGrafanaResult::ListClusterFromGrafanaResult() :
ServiceResult()
{}
ListClusterFromGrafanaResult::ListClusterFromGrafanaResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListClusterFromGrafanaResult::~ListClusterFromGrafanaResult()
{}
void ListClusterFromGrafanaResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPromClusterListNode = value["PromClusterList"]["PromCluster"];
for (auto valuePromClusterListPromCluster : allPromClusterListNode)
{
PromCluster promClusterListObject;
if(!valuePromClusterListPromCluster["Id"].isNull())
promClusterListObject.id = std::stol(valuePromClusterListPromCluster["Id"].asString());
if(!valuePromClusterListPromCluster["ClusterId"].isNull())
promClusterListObject.clusterId = valuePromClusterListPromCluster["ClusterId"].asString();
if(!valuePromClusterListPromCluster["ClusterName"].isNull())
promClusterListObject.clusterName = valuePromClusterListPromCluster["ClusterName"].asString();
if(!valuePromClusterListPromCluster["AgentStatus"].isNull())
promClusterListObject.agentStatus = valuePromClusterListPromCluster["AgentStatus"].asString();
if(!valuePromClusterListPromCluster["ClusterType"].isNull())
promClusterListObject.clusterType = valuePromClusterListPromCluster["ClusterType"].asString();
if(!valuePromClusterListPromCluster["ControllerId"].isNull())
promClusterListObject.controllerId = valuePromClusterListPromCluster["ControllerId"].asString();
if(!valuePromClusterListPromCluster["IsControllerInstalled"].isNull())
promClusterListObject.isControllerInstalled = valuePromClusterListPromCluster["IsControllerInstalled"].asString() == "true";
if(!valuePromClusterListPromCluster["UserId"].isNull())
promClusterListObject.userId = valuePromClusterListPromCluster["UserId"].asString();
if(!valuePromClusterListPromCluster["RegionId"].isNull())
promClusterListObject.regionId = valuePromClusterListPromCluster["RegionId"].asString();
if(!valuePromClusterListPromCluster["PluginsJsonArray"].isNull())
promClusterListObject.pluginsJsonArray = valuePromClusterListPromCluster["PluginsJsonArray"].asString();
if(!valuePromClusterListPromCluster["StateJson"].isNull())
promClusterListObject.stateJson = valuePromClusterListPromCluster["StateJson"].asString();
if(!valuePromClusterListPromCluster["NodeNum"].isNull())
promClusterListObject.nodeNum = std::stoi(valuePromClusterListPromCluster["NodeNum"].asString());
if(!valuePromClusterListPromCluster["CreateTime"].isNull())
promClusterListObject.createTime = std::stol(valuePromClusterListPromCluster["CreateTime"].asString());
if(!valuePromClusterListPromCluster["UpdateTime"].isNull())
promClusterListObject.updateTime = std::stol(valuePromClusterListPromCluster["UpdateTime"].asString());
if(!valuePromClusterListPromCluster["LastHeartBeatTime"].isNull())
promClusterListObject.lastHeartBeatTime = std::stol(valuePromClusterListPromCluster["LastHeartBeatTime"].asString());
if(!valuePromClusterListPromCluster["InstallTime"].isNull())
promClusterListObject.installTime = std::stol(valuePromClusterListPromCluster["InstallTime"].asString());
if(!valuePromClusterListPromCluster["Extra"].isNull())
promClusterListObject.extra = valuePromClusterListPromCluster["Extra"].asString();
if(!valuePromClusterListPromCluster["Options"].isNull())
promClusterListObject.options = valuePromClusterListPromCluster["Options"].asString();
promClusterList_.push_back(promClusterListObject);
}
}
std::vector<ListClusterFromGrafanaResult::PromCluster> ListClusterFromGrafanaResult::getPromClusterList()const
{
return promClusterList_;
}
| 49.76087 | 127 | 0.800568 | iamzken |
472c13c8bac9a4f62364f5a302fcda89a0af9315 | 1,776 | cpp | C++ | src/dot.cpp | Xazax-hun/conceptanalysis | d552889345ad2c8aff294bff21b1788f126b312a | [
"Apache-2.0"
] | null | null | null | src/dot.cpp | Xazax-hun/conceptanalysis | d552889345ad2c8aff294bff21b1788f126b312a | [
"Apache-2.0"
] | null | null | null | src/dot.cpp | Xazax-hun/conceptanalysis | d552889345ad2c8aff294bff21b1788f126b312a | [
"Apache-2.0"
] | null | null | null | #include "include/dot.h"
#include <sstream>
namespace {
Concept minimizedForDisplay(int conc, const Lattice& l, const ConceptContext& data) {
std::set<int> preds;
std::set<int> succs;
for (auto e : l.less) {
if (conc == e.second)
preds.insert(e.first);
if (conc == e.first)
succs.insert(e.second);
}
bitset oldAttrs(data.attributeNames.size(), false);
for (auto pred : preds)
oldAttrs = set_union(oldAttrs, l.concepts[pred].attributes);
bitset newAttrs = set_subtract(l.concepts[conc].attributes, oldAttrs);
bitset oldObjs(data.objectNames.size(), false);
for (auto succ : succs)
oldObjs = set_union(oldObjs, l.concepts[succ].objects);
bitset newObjs = set_subtract(l.concepts[conc].objects, oldObjs);
return {newObjs, newAttrs};
}
} // anonymous namespace
// TODO: introduce proper escaping.
std::string renderDot(const Lattice& l, const ConceptContext& data) {
std::stringstream dot;
dot << "digraph concept_lattice {\n";
dot << "splines = false\n";
dot << "edge [dir=none tailport=\"s\" headport=\"n\"]\n";
dot << "node [shape=record]\n\n";
for (unsigned i = 0; i < l.concepts.size(); ++i) {
auto conc = minimizedForDisplay(i, l, data);
dot << "node" << i << " [label=\"";
for (int i : to_sparse(conc.objects)) {
dot << data.objectNames[i] << " ";
}
dot << "|";
for (int i : to_sparse(conc.attributes)) {
dot << data.attributeNames[i] << " ";
}
dot << "\"];\n";
}
dot << "\n";
for (auto e : l.less) {
dot << "node" << e.first << " -> " << "node" << e.second << ";\n";
}
dot << "}\n";
return std::move(dot).str();
} | 29.6 | 85 | 0.561937 | Xazax-hun |
472c5da2e930d392c22ee1c4e325cce03f433956 | 1,241 | cpp | C++ | lanqiao/2022/b.cpp | Zilanlann/cp-code | 0500acbf6fb05a66f7bdbdf0e0a8bd6170126a4a | [
"MIT"
] | 3 | 2022-03-30T14:14:57.000Z | 2022-03-31T04:30:32.000Z | lanqiao/2022/b.cpp | Zilanlann/cp-code | 0500acbf6fb05a66f7bdbdf0e0a8bd6170126a4a | [
"MIT"
] | null | null | null | lanqiao/2022/b.cpp | Zilanlann/cp-code | 0500acbf6fb05a66f7bdbdf0e0a8bd6170126a4a | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
bool solve(string v) {
for (int i = 0; i < 8 - 2; i++) {
if (v[i + 2] == v[i + 1] + 1 && v[i + 1] == v[i] + 1) {
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//IO
//freopen("bout.txt", "w", stdout);
int cnt = 0;
string s = "2022";
for (int i = 1; i <= 12; i++) {
string str = s;
if (i < 10) {
str += '0';
}
str += to_string(i);
if (i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
for (int j = 1; j <= 31; j++) {
string v = str;
if (j < 10) {
v += '0';
}
v += to_string(j);
if (solve(v)) cnt++;
//cout << v << '\n';
}
}
else if (i == 4 || i == 6 || i == 9 || i == 11) {
for (int j = 1; j <= 30; j++) {
string v = str;
if (j < 10) {
v += '0';
}
v += to_string(j);
if (solve(v)) cnt++;
//cout << v << '\n';
}
}
else {
for (int j = 1; j <= 28; j++) {
string v = str;
if (j < 10) {
v += '0';
}
v += to_string(j);
if (solve(v)) cnt++;
//cout << v << "\n";
}
}
}
cout << cnt << "\n";
return 0;
}
| 18.522388 | 78 | 0.362611 | Zilanlann |
472f9ace358db5d80a235e2ea0ee961ee0f74f09 | 970 | cpp | C++ | lib/homie/node/node.cpp | 2SmartCloud/2smart-cloud-esp8266-boilerplate | c40dace65f5ce5f27677b039ae8bb1e123a66723 | [
"MIT"
] | 2 | 2021-11-16T15:21:09.000Z | 2021-11-19T17:07:37.000Z | lib/homie/node/node.cpp | 2SmartCloud/2smart-cloud-esp8266-sonoff-s20 | 721e6f159fe4d7b2a630e21cd012507d8bb5085b | [
"MIT"
] | null | null | null | lib/homie/node/node.cpp | 2SmartCloud/2smart-cloud-esp8266-sonoff-s20 | 721e6f159fe4d7b2a630e21cd012507d8bb5085b | [
"MIT"
] | null | null | null | #include "node.h"
#include <utility>
Node::Node(const char* name, const char* id, Device* device) {
name_ = name;
id_ = id;
device_ = device;
}
bool Node::Init(Homie* homie) {
homie_ = homie;
homie->Publish(*this, "name", name_, true);
homie->Publish(*this, "state", state_, true);
bool status = true;
for (auto it = begin(properties_); it != end(properties_); ++it) {
if (!(*it->second).Init(homie_)) status = false;
}
return status;
}
void Node::AddProperty(Property* property) {
properties_.insert(std::pair<String, Property*>((property->GetId()).c_str(), property));
}
String Node::GetId() const { return id_; }
Device* Node::GetDevice() const { return this->device_; }
Property* Node::GetProperty(String id) { return properties_.find(id)->second; }
void Node::HandleCurrentState() {
for (auto it = begin(properties_); it != end(properties_); ++it) {
(*it->second).HandleCurrentState();
}
}
| 26.944444 | 92 | 0.63299 | 2SmartCloud |
47325ac39c029ba65ebc59db7c4736ee05d3eb80 | 282 | cpp | C++ | Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_5_float.cpp | mmmspatz/kalibr | e2e881e5d25d378f0c500c67e00532ee1c1082fd | [
"BSD-4-Clause"
] | null | null | null | Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_5_float.cpp | mmmspatz/kalibr | e2e881e5d25d378f0c500c67e00532ee1c1082fd | [
"BSD-4-Clause"
] | null | null | null | Schweizer-Messer/numpy_eigen/src/autogen_test_module/test_D_5_float.cpp | mmmspatz/kalibr | e2e881e5d25d378f0c500c67e00532ee1c1082fd | [
"BSD-4-Clause"
] | null | null | null | #include <eigen3/Eigen/Core>
#include <numpy_eigen/boost_python_headers.hpp>
Eigen::Matrix<float, Eigen::Dynamic, 5> test_float_D_5(const Eigen::Matrix<float, Eigen::Dynamic, 5> & M)
{
return M;
}
void export_float_D_5()
{
boost::python::def("test_float_D_5",test_float_D_5);
}
| 21.692308 | 105 | 0.744681 | mmmspatz |
47343ea6154bcd0c7bc45a4d0d7dfe96fd63044f | 3,974 | hpp | C++ | palette.hpp | rsenn/qjs-opencv | 8035073ad8360636b816700325d92f4934e47e63 | [
"MIT"
] | null | null | null | palette.hpp | rsenn/qjs-opencv | 8035073ad8360636b816700325d92f4934e47e63 | [
"MIT"
] | null | null | null | palette.hpp | rsenn/qjs-opencv | 8035073ad8360636b816700325d92f4934e47e63 | [
"MIT"
] | null | null | null | #ifndef PALETTE_HPP
#define PALETTE_HPP
#include "jsbindings.hpp"
#include "js_array.hpp"
#include <opencv2/core/hal/interface.h>
#include <opencv2/core/mat.hpp>
#include <opencv2/core/mat.inl.hpp>
#include <cstdio>
template<class Container>
static inline void
palette_read(JSContext* ctx, JSValueConst arr, Container& out, float factor = 1.0f) {
size_t i, len = js_array_length(ctx, arr);
for(i = 0; i < len; i++) {
cv::Scalar scalar;
JSColorData<uint8_t> color;
JSValue item = JS_GetPropertyUint32(ctx, arr, i);
js_array_to(ctx, item, scalar);
JS_FreeValue(ctx, item);
std::transform(&scalar[0], &scalar[4], color.arr.begin(), [factor](double val) -> uint8_t { return val * factor; });
out.push_back(color);
}
}
template<class Pixel>
static inline void
palette_apply(const cv::Mat& src, JSOutputArray dst, Pixel palette[256]) {
cv::Mat result(src.size(), CV_8UC3);
// printf("result.size() = %ux%u\n", result.cols, result.rows);
// printf("result.channels() = %u\n", result.channels());
// printf("src.elemSize() = %zu\n", src.elemSize());
// printf("result.elemSize() = %zu\n", result.elemSize());
// printf("result.ptr<Pixel>(0,1) - result.ptr<Pixel>(0,0) = %zu\n", reinterpret_cast<uchar*>(result.ptr<Pixel>(0, 1)) -
// reinterpret_cast<uchar*>(result.ptr<Pixel>(0, 0)));
for(int y = 0; y < src.rows; y++) {
for(int x = 0; x < src.cols; x++) {
uchar index = src.at<uchar>(y, x);
result.at<Pixel>(y, x) = palette[index];
}
}
result.copyTo(dst.getMatRef());
}
static inline float
square(float x) {
return x * x;
}
template<class ColorType>
static inline JSColorData<float>
color3f(const ColorType& c) {
JSColorData<float> ret;
ret.b = float(c.b) / 255.0;
ret.g = float(c.g) / 255.0;
ret.r = float(c.r) / 255.0;
return ret;
}
template<class ColorType>
static inline float
color_distance_squared(const ColorType& c1, const ColorType& c2) {
JSColorData<float> a = color3f(c1), b = color3f(c2);
// NOTE: from https://www.compuphase.com/cmetric.htm
float mean_r = (a.r + b.r) * 0.5f;
float dr = a.r - b.r;
float dg = a.g - b.g;
float db = a.b - b.b;
return ((2.0f + mean_r * (1.0f / 256.0f)) * square(dr) + (4.0f * square(dg)) + (2.0f + ((255.0f - mean_r) * (1.0f / 256.0f))) * square(db));
}
template<class ColorType>
static inline int
find_nearest(const ColorType& color, const std::vector<ColorType>& palette, int skip = -1) {
int index, ret = -1, size = palette.size();
float distance = std::numeric_limits<float>::max();
for(index = 0; index < size; index++) {
if(index == skip)
continue;
float newdist = color_distance_squared(color, palette[index]);
if(newdist < distance) {
distance = newdist;
ret = index;
}
}
return ret;
}
template<class ColorType>
static inline void
palette_match(const cv::Mat& src, JSOutputArray dst, const std::vector<ColorType>& palette, int transparent = -1) {
cv::Mat result(src.rows, src.cols, CV_8U);
const uchar* ptr(src.ptr());
size_t step(src.step);
size_t elem_size(src.elemSize());
if(transparent == -1) {
for(int y = 0; y < src.rows; y++) {
for(int x = 0; x < src.cols; x++) {
const ColorType& color = *reinterpret_cast<const ColorType*>(ptr + (x * elem_size));
int index = find_nearest(color, palette);
if((int)(unsigned int)(uchar)index == index)
result.at<uchar>(y, x) = index;
}
ptr += step;
}
} else {
for(int y = 0; y < src.rows; y++) {
for(int x = 0; x < src.cols; x++) {
const ColorType& color = *reinterpret_cast<const ColorType*>(ptr + (x * elem_size));
int index = color.a > 127 ? find_nearest(color, palette, transparent) : transparent;
if((int)(unsigned int)(uchar)index == index)
result.at<uchar>(y, x) = index;
}
ptr += step;
}
}
dst.assign(result); // result.copyTo(dst.getMatRef());
}
#endif /* PALETTE_HPP */
| 28.797101 | 142 | 0.624811 | rsenn |