hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4b53deea56787cb6b802da4d1dc5e7358e42ed8a | 10,359 | cc | C++ | src/Worker.cc | tsw303005/MapReduce | e29778a439210963a7cd8047e55123e0c810b79b | [
"MIT"
] | null | null | null | src/Worker.cc | tsw303005/MapReduce | e29778a439210963a7cd8047e55123e0c810b79b | [
"MIT"
] | null | null | null | src/Worker.cc | tsw303005/MapReduce | e29778a439210963a7cd8047e55123e0c810b79b | [
"MIT"
] | null | null | null | #include "Worker.h"
Worker::Worker(char **argv, int cpu_num, int rank, int size) {
this->job_name = std::string(argv[1]);
this->num_reducer = std::stoi(argv[2]);
this->delay = std::stoi(argv[3]);
this->input_filename = std::string(argv[4]);
this->chunk_size = std::stoi(argv[5]);
this->output_dir = std::string(argv[7]);
this->rank = rank;
this->cpu_num = cpu_num;
this->node_num = rank;
this->available_num = 0;
this->scheduler_index = size - 1;
this->mapper_thread_number = cpu_num - 1;
this->reducer_thread_number = 1;
this->threads = new pthread_t[cpu_num];
this->lock = new std::mutex;
this->send_lock = new std::mutex;
}
Worker::~Worker() {
delete this->lock;
delete this->send_lock;
std::cout << "[Info]: Worker "<< this->rank << " terminate\n";
}
void Worker::DeleteFile(std::string filename) {
int result = 0;
char *f = NULL;
f = (char*)malloc(sizeof(char) * (filename.length() + 1));
for (int i = 0; i < filename.length(); i++) {
f[i] = filename[i];
}
f[filename.length()] = '\0';
result = std::remove(f);
if (result != -1) {
std::cout << "[Info]: Remove file " << filename << " successfully\n";
}
free(f);
}
void Worker::ThreadPoolMapper() {
bool task_finished = false;
MPI_Status status;
int signal = 1;
int request[2];
int chunk_index[2];
this->job_mapper = new std::queue<Chunk>;
this->job_finished = new std::queue<int>;
// allocate mapper thread
for (int i = 0; i < this->mapper_thread_number; i++) {
pthread_create(&this->threads[i], NULL, Worker::MapperFunction, (void*)this);
}
while (!task_finished) {
// check available thread number
while (this->available_num == 0);
request[0] = 0;
request[1] = 0;
MPI_Send(request, 2, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD);
MPI_Recv(chunk_index, 2, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD, &status);
this->lock->lock();
this->job_mapper->push({chunk_index[0], chunk_index[1]});
this->lock->unlock();
// mapper job done
if (chunk_index[0] == -1) {
task_finished = true;
}
}
// check all mapper thread return
for (int i = 0; i < this->mapper_thread_number; i++) {
pthread_join(this->threads[i], NULL);
}
while (!this->job_finished->empty()) {
request[0] = 1;
request[1] = this->job_finished->front();
MPI_Send(request, 2, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD);
this->job_finished->pop();
}
// delete queue
delete this->job_mapper;
delete this->job_finished;
MPI_Barrier(MPI_COMM_WORLD);
}
void Worker::ThreadPoolReducer() {
bool task_finished = false;
MPI_Status status;
int signal = 1;
int request[2];
int reducer_index;
this->job_reducer = new std::queue<int>;
this->job_finished = new std::queue<int>;
for (int i = 0; i < this->reducer_thread_number; i++) {
pthread_create(&this->threads[i], NULL, Worker::ReducerFunction, this);
}
while (!task_finished) {
// check available thread
while (this->available_num == 0);
request[0] = 0;
request[1] = 0;
MPI_Send(request, 2, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD);
MPI_Recv(&reducer_index, 1, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD, &status);
this->lock->lock();
this->job_reducer->push(reducer_index);
this->lock->unlock();
if (reducer_index == -1) { // reducer job done
task_finished = true;
}
}
// check all mapper thread return
for (int i = 0; i < this->reducer_thread_number; i++) {
pthread_join(this->threads[i], NULL);
}
while (!this->job_finished->empty()) {
request[0] = 1;
request[1] = this->job_finished->front();
MPI_Send(request, 2, MPI_INT, this->scheduler_index, 0, MPI_COMM_WORLD);
this->job_finished->pop();
}
// delete queue
delete this->job_reducer;
delete this->job_finished;
MPI_Barrier(MPI_COMM_WORLD);
}
void* Worker::MapperFunction(void *input) {
Worker *mapper = (Worker*)input;
Count *word_count = new Count;
Word *words = new Word;
Chunk chunk;
bool task_finished = false;
while (!task_finished) {
chunk.first = -1;
mapper->lock->lock();
if (!mapper->job_mapper->empty()) {
chunk = mapper->job_mapper->front();
if (chunk.first == -1) {
task_finished = true;
} else {
mapper->available_num -= 1;
mapper->job_mapper->pop();
}
}
mapper->lock->unlock();
if (chunk.first != -1) {
if (chunk.second != mapper->rank && WAIT) {
sleep(mapper->delay);
}
word_count->clear();
words->clear();
// Input Split
mapper->InputSplit(chunk.first, word_count, words);
// get word partition number
std::vector<std::vector<std::string>> split_result(mapper->num_reducer + 1);
for (auto word : *words) {
split_result[mapper->Partition(mapper->num_reducer, word)].push_back(word);
}
// generate intermediate file
for (int i = 1; i <= mapper->num_reducer; i++) {
std::string chunk_str = std::to_string(chunk.first);
std::string reducer_num_str = std::to_string(i);
std::string filename = "./intermediate_file/" + chunk_str + "_" + reducer_num_str + ".txt";
std::ofstream myfile(filename);
for (auto word : split_result[i]) {
myfile << word << " " << (*word_count)[word] << "\n";
}
myfile.close();
}
mapper->lock->lock();
mapper->job_finished->push(chunk.first);
mapper->available_num += 1;
mapper->lock->unlock();
}
}
delete word_count;
delete words;
pthread_exit(NULL);
}
void Worker::InputSplit(int chunk, Count *word_count, Word *words) {
int start_pos = 1 + (chunk - 1) * this->chunk_size;
// read chunk file
std::ifstream input_file(this->input_filename);
std::string line;
// find the chunk start position
for (int i = 1; i < start_pos; i++) {
getline(input_file, line);
}
for (int i = 1; i <= this->chunk_size; i++) {
getline(input_file, line);
this->Map(line, word_count, words);
}
input_file.close();
}
void Worker::Map(std::string line, Count *word_count, Word *words) {
int pos = 0;
std::string word;
std::vector<std::string> tmp_words;
while ((pos = line.find(" ")) != std::string::npos) {
word = line.substr(0, pos);
tmp_words.push_back(word);
line.erase(0, pos + 1);
}
if (!line.empty())
tmp_words.push_back(line);
for (auto w : tmp_words) {
if (word_count->count(w) == 0) {
words->push_back(w);
(*word_count)[w] = 1;
} else {
(*word_count)[w] += 1;
}
}
}
int Worker::Partition(int num_reducer, std::string word) {
return ((word.length() % num_reducer) + 1);
}
void* Worker::ReducerFunction(void* input) {
Worker *reducer = (Worker*)input;
Count *word_count = new Count;
Total *total = new Total;
Collect *group = new Collect;
int task;
bool task_finished = false;
while (!task_finished) {
task = -1;
reducer->lock->lock();
if (!reducer->job_reducer->empty()) {
task = reducer->job_reducer->front();
if (task == -1) {
task_finished = true;
} else {
reducer->available_num -= 1;
reducer->job_reducer->pop();
}
}
reducer->lock->unlock();
if (task != -1) {
word_count->clear();
total->clear();
group->clear();
// read intermediate file
reducer->ReadFile(task, total);
// sort words
reducer->Sort(total);
// group
reducer->Group(total, group);
// reduce
reducer->Reduce(group, word_count);
// output
reducer->Output(word_count, task);
reducer->lock->lock();
reducer->job_finished->push(task);
reducer->available_num += 1;
reducer->lock->unlock();
}
}
delete word_count;
delete total;
delete group;
pthread_exit(NULL);
}
void Worker::ReadFile(int task, Total *total) {
std::string filename;
std::string reducer_num_str = std::to_string(task);
std::string word;
int count;
filename = "./intermediate_file/" + reducer_num_str + ".txt";
std::ifstream input_file(filename);
while (input_file >> word >> count) {
total->push_back({word, count});
}
input_file.close();
DeleteFile(filename);
}
bool Worker::cmp(Item a, Item b) {
return a.first < b.first;
}
void Worker::Sort(Total *total) {
sort(total->begin(), total->end(), cmp);
}
void Worker::Group(Total *total, Collect *group) {
for (auto item : *total) {
if (group->count(item.first) == 0) {
std::vector<int> tmp_vec;
tmp_vec.clear();
(*group)[item.first] = tmp_vec;
(*group)[item.first].push_back(item.second);
} else {
(*group)[item.first].push_back(item.second);
}
}
}
void Worker::Reduce(Collect *group, Count *word_count) {
for (auto item : *group) {
(*word_count)[item.first] = 0;
for (auto num : item.second) {
(*word_count)[item.first] += num;
}
}
}
void Worker::Output(Count *word_count, int task) {
std::string task_str = std::to_string(task);
std::string filename = this->output_dir + this->job_name + "-" + task_str + ".out";
std::ofstream myfile(filename);
for (auto word : *word_count) {
myfile << word.first << " " << word.second << "\n";
}
myfile.close();
} | 28.458791 | 107 | 0.551212 | tsw303005 |
4b544ad0ecd7ada690a6c1b109de0382c6378e86 | 3,501 | hpp | C++ | heart/src/problem/cell_factories/PlaneStimulusCellFactory.hpp | stu-l/Chaste | 8efa8b440660553af66804067639f237c855f557 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | heart/src/problem/cell_factories/PlaneStimulusCellFactory.hpp | stu-l/Chaste | 8efa8b440660553af66804067639f237c855f557 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | heart/src/problem/cell_factories/PlaneStimulusCellFactory.hpp | stu-l/Chaste | 8efa8b440660553af66804067639f237c855f557 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | /*
Copyright (c) 2005-2022, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
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 University of Oxford nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PLANESTIMULUSCELLFACTORY_HPP_
#define PLANESTIMULUSCELLFACTORY_HPP_
#include <boost/shared_ptr.hpp>
#include "AbstractCardiacCellFactory.hpp"
#include "LogFile.hpp"
#include "SimpleStimulus.hpp"
/**
* PlaneStimulusCellFactory provides cells within 1e-5 of x=0 with a SimpleStimulus.
*/
template<class CELL, unsigned ELEMENT_DIM, unsigned SPACE_DIM = ELEMENT_DIM>
class PlaneStimulusCellFactory : public AbstractCardiacCellFactory<ELEMENT_DIM,SPACE_DIM>
{
protected:
/** The stimulus to apply at stimulated nodes */
boost::shared_ptr<SimpleStimulus> mpStimulus;
public:
/**
* Constructor
* @param stimulusMagnitude The magnitude of the simple stimulus to be applied (defaults to -600).
* @param stimulusDuration The duration of the simple stimulus to be applied (defaults to 0.5ms).
*/
PlaneStimulusCellFactory(double stimulusMagnitude=-600, double stimulusDuration=0.5)
: AbstractCardiacCellFactory<ELEMENT_DIM,SPACE_DIM>()
{
mpStimulus.reset(new SimpleStimulus(stimulusMagnitude, stimulusDuration));
LOG(1, "Defined a PlaneStimulusCellFactory<"<<SPACE_DIM<<"> with SimpleStimulus("<<stimulusMagnitude<<","<< stimulusDuration<< ")\n");
}
/**
* @param pNode Pointer to the node.
* @return A cardiac cell which corresponds to this node.
*/
AbstractCardiacCellInterface* CreateCardiacCellForTissueNode(Node<SPACE_DIM>* pNode)
{
double x = pNode->GetPoint()[0];
///\todo remove magic number? (#1884)
if (x*x<=1e-10)
{
return new CELL(this->mpSolver, mpStimulus);
}
else
{
return new CELL(this->mpSolver, this->mpZeroStimulus);
}
}
};
#endif /*PLANESTIMULUSCELLFACTORY_HPP_*/
| 38.472527 | 142 | 0.748072 | stu-l |
4b57dce6491d197f21456d7d3dbb59514309aad5 | 5,034 | cpp | C++ | src/VK/base/ExtFreeSync2.cpp | Zakhrov/Cauldron | 6c50024f6cd4495a1c6d18a58fa4875072ffa243 | [
"MIT"
] | 1 | 2019-07-24T12:02:40.000Z | 2019-07-24T12:02:40.000Z | src/VK/base/ExtFreeSync2.cpp | Zakhrov/Cauldron | 6c50024f6cd4495a1c6d18a58fa4875072ffa243 | [
"MIT"
] | null | null | null | src/VK/base/ExtFreeSync2.cpp | Zakhrov/Cauldron | 6c50024f6cd4495a1c6d18a58fa4875072ffa243 | [
"MIT"
] | null | null | null | // AMD AMDUtils code
//
// Copyright(c) 2018 Advanced Micro Devices, Inc.All rights reserved.
// 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 "ExtFreeSync2.h"
#include "Misc/Misc.h"
#include <vulkan/vulkan.h>
namespace CAULDRON_VK
{
static PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR g_vkGetPhysicalDeviceSurfaceCapabilities2KHR = nullptr;
static PFN_vkGetDeviceProcAddr g_vkGetDeviceProcAddr = nullptr;
static PFN_vkSetHdrMetadataEXT g_vkSetHdrMetadataEXT = nullptr;
#ifdef _WIN32
static PFN_vkAcquireFullScreenExclusiveModeEXT g_vkAcquireFullScreenExclusiveModeEXT = nullptr;
static PFN_vkReleaseFullScreenExclusiveModeEXT g_vkReleaseFullScreenExclusiveModeEXT = nullptr;
#endif
static PFN_vkGetPhysicalDeviceSurfaceFormats2KHR g_vkGetPhysicalDeviceSurfaceFormats2KHR = nullptr;
#ifdef _WIN32
static PFN_vkGetDeviceGroupSurfacePresentModes2EXT g_vkGetDeviceGroupSurfacePresentModes2EXT = nullptr;
static PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT g_vkGetPhysicalDeviceSurfacePresentModes2EXT = nullptr;
static PFN_vkSetLocalDimmingAMD g_vkSetLocalDimmingAMD = nullptr;
#endif
static PFN_vkGetPhysicalDevicePresentRectanglesKHR g_vkGetPhysicalDevicePresentRectanglesKHR = nullptr;
bool ExtFreeSync2CheckExtensions(DeviceProperties *pDP)
{
bool res = true;
#ifdef _WIN32
std::vector<const char *> required_extension_names = { VK_EXT_HDR_METADATA_EXTENSION_NAME, VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME, VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME };
for (auto& ext : required_extension_names)
{
if (pDP->Add(ext) == false)
{
Trace(format("FreeSync2 disabled, missing extension: %s\n", ext));
res = false;
}
}
#else
res = false;
Trace(format("FreeSync2 disabled, unsupported platform"));
#endif
return res;
}
void ExtFreeSync2Init(VkInstance instance)
{
g_vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr");
assert(g_vkGetDeviceProcAddr);
g_vkGetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR");
assert(g_vkGetPhysicalDeviceSurfaceFormats2KHR);
#ifdef _WIN32
g_vkGetPhysicalDeviceSurfacePresentModes2EXT = (PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT");
assert(g_vkGetPhysicalDeviceSurfacePresentModes2EXT);
g_vkGetDeviceGroupSurfacePresentModes2EXT = (PFN_vkGetDeviceGroupSurfacePresentModes2EXT)vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModes2EXT");
assert(g_vkGetDeviceGroupSurfacePresentModes2EXT);
#endif
}
void ExtFreeSync2Init(VkDevice device)
{
g_vkSetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)g_vkGetDeviceProcAddr(device, "vkSetHdrMetadataEXT");
assert(g_vkSetHdrMetadataEXT);
#ifdef _WIN32
g_vkAcquireFullScreenExclusiveModeEXT = (PFN_vkAcquireFullScreenExclusiveModeEXT)g_vkGetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT");
assert(g_vkAcquireFullScreenExclusiveModeEXT);
g_vkReleaseFullScreenExclusiveModeEXT = (PFN_vkReleaseFullScreenExclusiveModeEXT)g_vkGetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT");
assert(g_vkReleaseFullScreenExclusiveModeEXT);
g_vkSetLocalDimmingAMD = (PFN_vkSetLocalDimmingAMD)g_vkGetDeviceProcAddr(device, "vkSetLocalDimmingAMD");
assert(g_vkSetLocalDimmingAMD);
#endif
g_vkGetPhysicalDevicePresentRectanglesKHR = (PFN_vkGetPhysicalDevicePresentRectanglesKHR)g_vkGetDeviceProcAddr(device, "vkGetPhysicalDevicePresentRectanglesKHR");
assert(g_vkGetPhysicalDevicePresentRectanglesKHR);
}
} | 48.403846 | 187 | 0.77056 | Zakhrov |
4b5917d3c368dd0f8781755970b0334e422fdd9a | 1,101 | cpp | C++ | 0001-0100/0073.cpp | YKR/LeetCode2019 | e4c6346eae5c7b85ba53249c46051700a73dd95e | [
"MIT"
] | null | null | null | 0001-0100/0073.cpp | YKR/LeetCode2019 | e4c6346eae5c7b85ba53249c46051700a73dd95e | [
"MIT"
] | null | null | null | 0001-0100/0073.cpp | YKR/LeetCode2019 | e4c6346eae5c7b85ba53249c46051700a73dd95e | [
"MIT"
] | null | null | null | class Solution {
public:
void setZeroes(vector<vector<int>>& matrix) {
if (matrix.empty() || matrix[0].empty()) return;
int n = matrix.size(), m = matrix[0].size();
bool lastRowZero = false;
for (int j = 0; j < m; ++j)
if (matrix[0][j] == 0)
{
lastRowZero = true;
break;
}
for (int i = 1; i < n; ++i)
{
bool thisRowZero = false;
for (int j = 0; j < m; ++j)
if (matrix[i][j] == 0)
{
thisRowZero = true;
for (int k = i - 1; k >= 0; --k)
matrix[k][j] = 0;
}
for (int j = 0; j < m; ++j)
if (matrix[i-1][j] == 0)
matrix[i][j] = 0;
if (lastRowZero)
for (int j = 0; j < m; ++j)
matrix[i-1][j] = 0;
lastRowZero = thisRowZero;
}
if (lastRowZero)
for (int j = 0; j < m; ++j)
matrix[n-1][j] = 0;
}
}; | 31.457143 | 56 | 0.347866 | YKR |
4b5cf1061cc899d4e701a0869bad5e25290fd409 | 176 | hpp | C++ | src/HTMLElements/HTMLHeadElement.hpp | windlessStorm/WebWhir | 0ed261427d4f4e4f81b62816dc0d94bfacd0890b | [
"MIT"
] | 90 | 2017-04-03T21:42:57.000Z | 2022-01-22T11:08:56.000Z | src/HTMLElements/HTMLHeadElement.hpp | windlessStorm/WebWhir | 0ed261427d4f4e4f81b62816dc0d94bfacd0890b | [
"MIT"
] | 21 | 2017-03-06T21:45:36.000Z | 2017-03-06T21:45:37.000Z | src/HTMLElements/HTMLHeadElement.hpp | windlessStorm/WebWhir | 0ed261427d4f4e4f81b62816dc0d94bfacd0890b | [
"MIT"
] | 17 | 2017-04-15T22:42:13.000Z | 2021-12-20T09:50:15.000Z | #ifndef HTMLHEADELEMENT_H
#define HTMLHEADELEMENT_H
#include "HTMLElement.hpp"
class HTMLHeadElement : public HTMLElement
{
public:
HTMLHeadElement();
};
#endif
| 13.538462 | 42 | 0.738636 | windlessStorm |
4b5d7d1c3d2bcdbfcb3610abe894088b437df312 | 2,087 | cpp | C++ | src/stubgenerator/stubgenerator.cpp | WinBuilds/libjson-rpc-cpp | eb3404156b389f3e76e859ca764a2f1a45da3bb5 | [
"MIT"
] | null | null | null | src/stubgenerator/stubgenerator.cpp | WinBuilds/libjson-rpc-cpp | eb3404156b389f3e76e859ca764a2f1a45da3bb5 | [
"MIT"
] | null | null | null | src/stubgenerator/stubgenerator.cpp | WinBuilds/libjson-rpc-cpp | eb3404156b389f3e76e859ca764a2f1a45da3bb5 | [
"MIT"
] | null | null | null | /*************************************************************************
* libjson-rpc-cpp
*************************************************************************
* @file stubgenerator.cpp
* @date 01.05.2013
* @author Peter Spiess-Knafl <[email protected]>
* @license See attached LICENSE.txt
************************************************************************/
#include <algorithm>
#include <fstream>
#include <jsonrpccpp/common/specificationparser.h>
#include <argtable/argtable3.h>
#include "client/cppclientstubgenerator.h"
#include "client/jsclientstubgenerator.h"
#include "client/pyclientstubgenerator.h"
#include "helper/cpphelper.h"
#include "server/cppserverstubgenerator.h"
#include "stubgenerator.h"
using namespace std;
using namespace jsonrpc;
#define EXIT_ERROR(X) \
cerr << X << endl; \
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0])); \
return 1;
StubGenerator::StubGenerator(const string &stubname,
std::vector<Procedure> &procedures,
ostream &outputstream)
: CodeGenerator(outputstream), stubname(stubname), procedures(procedures) {}
StubGenerator::StubGenerator(const string &stubname,
std::vector<Procedure> &procedures,
const std::string &filename)
: CodeGenerator(filename), stubname(stubname), procedures(procedures) {}
StubGenerator::~StubGenerator() {}
string StubGenerator::replaceAll(const string &text, const string &fnd,
const string &rep) {
string result = text;
replaceAll2(result, fnd, rep);
return result;
}
void StubGenerator::replaceAll2(string &result, const string &find,
const string &replace) {
size_t pos = result.find(find);
while (pos != string::npos) {
result.replace(pos, find.length(), replace);
pos = result.find(find, pos + replace.length());
}
}
| 35.982759 | 80 | 0.55103 | WinBuilds |
4b5dee04ebcc36f796ac7481fa4d22eb71b1bbd2 | 866 | cpp | C++ | API/Driver/OpenGL/src/Command/Query.cpp | Gpinchon/OCRA | 341bb07facc616f1f8a27350054d1e86f022d7c6 | [
"Apache-2.0"
] | null | null | null | API/Driver/OpenGL/src/Command/Query.cpp | Gpinchon/OCRA | 341bb07facc616f1f8a27350054d1e86f022d7c6 | [
"Apache-2.0"
] | null | null | null | API/Driver/OpenGL/src/Command/Query.cpp | Gpinchon/OCRA | 341bb07facc616f1f8a27350054d1e86f022d7c6 | [
"Apache-2.0"
] | null | null | null | #include <GL/Command/Buffer.hpp>
#include <GL/QueryPool.hpp>
OCRA_DECLARE_HANDLE(OCRA::Command::Buffer);
OCRA_DECLARE_HANDLE(OCRA::QueryPool);
namespace OCRA::Command
{
void BeginQuery(
const Command::Buffer::Handle& a_CommandBuffer,
const QueryPool::Handle& a_QueryPool,
const uint32_t& a_QueryIndex)
{
a_CommandBuffer->PushCommand([queryPool = a_QueryPool, queryIndex = a_QueryIndex](Buffer::ExecutionState& a_ExecutionState) {
queryPool->Begin(queryIndex);
});
}
void EndQuery(
const Command::Buffer::Handle& a_CommandBuffer,
const QueryPool::Handle& a_QueryPool,
const uint32_t& a_QueryIndex)
{
a_CommandBuffer->PushCommand([queryPool = a_QueryPool, queryIndex = a_QueryIndex](Buffer::ExecutionState& a_ExecutionState) {
queryPool->End(queryIndex);
});
}
} | 32.074074 | 129 | 0.69746 | Gpinchon |
4b5f0b462215ce3c27fb8d26902faf397c88f791 | 18,192 | cpp | C++ | rmf_fleet_adapter/rmf_rxcpp/RxCpp-4.1.0/Rx/v2/test/operators/publish.cpp | Capstone-S13/rmf_ros2 | 66721dd2ab5a458c050bad154c6a17d8e4b5c8f4 | [
"Apache-2.0"
] | 1,451 | 2018-05-04T21:36:08.000Z | 2022-03-27T07:42:45.000Z | rmf_fleet_adapter/rmf_rxcpp/RxCpp-4.1.0/Rx/v2/test/operators/publish.cpp | Capstone-S13/rmf_ros2 | 66721dd2ab5a458c050bad154c6a17d8e4b5c8f4 | [
"Apache-2.0"
] | 150 | 2018-05-10T10:38:19.000Z | 2022-03-24T14:15:11.000Z | rmf_fleet_adapter/rmf_rxcpp/RxCpp-4.1.0/Rx/v2/test/operators/publish.cpp | Capstone-S13/rmf_ros2 | 66721dd2ab5a458c050bad154c6a17d8e4b5c8f4 | [
"Apache-2.0"
] | 220 | 2018-05-05T08:11:16.000Z | 2022-03-13T10:34:41.000Z | #include "../test.h"
#include <rxcpp/operators/rx-publish.hpp>
#include <rxcpp/operators/rx-connect_forever.hpp>
#include <rxcpp/operators/rx-ref_count.hpp>
#include <rxcpp/operators/rx-map.hpp>
#include <rxcpp/operators/rx-merge.hpp>
SCENARIO("publish range", "[!hide][range][subject][publish][subject][operators]"){
GIVEN("a range"){
WHEN("published"){
auto published = rxs::range<int>(0, 10).publish();
std::cout << "subscribe to published" << std::endl;
published.subscribe(
// on_next
[](int v){std::cout << v << ", ";},
// on_completed
[](){std::cout << " done." << std::endl;});
std::cout << "connect to published" << std::endl;
published.connect();
}
WHEN("ref_count is used"){
auto published = rxs::range<int>(0, 10).publish().ref_count();
std::cout << "subscribe to ref_count" << std::endl;
published.subscribe(
// on_next
[](int v){std::cout << v << ", ";},
// on_completed
[](){std::cout << " done." << std::endl;});
}
WHEN("connect_forever is used"){
auto published = rxs::range<int>(0, 10).publish().connect_forever();
std::cout << "subscribe to connect_forever" << std::endl;
published.subscribe(
// on_next
[](int v){std::cout << v << ", ";},
// on_completed
[](){std::cout << " done." << std::endl;});
}
}
}
SCENARIO("publish ref_count", "[range][subject][publish][ref_count][operators]"){
GIVEN("a range"){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<double> on;
const rxsc::test::messages<long> out;
static const long start_created = 0;
static const long start_subscribed = 100;
static const long start_unsubscribed = 200;
static const auto next_time = start_subscribed + 1;
static const auto completed_time = next_time + 1;
auto xs = sc.make_hot_observable({ // [0.0, 10.0]
on.next(next_time, 0.0),
on.next(next_time, 1.0),
on.next(next_time, 2.0),
on.next(next_time, 3.0),
on.next(next_time, 4.0),
on.next(next_time, 5.0),
on.next(next_time, 6.0),
on.next(next_time, 7.0),
on.next(next_time, 8.0),
on.next(next_time, 9.0),
on.next(next_time, 10.0),
on.completed(completed_time)
});
auto xs3 = sc.make_hot_observable({ // [0.0, 3.0]
on.next(next_time, 0.0),
on.next(next_time, 1.0),
on.next(next_time, 2.0),
on.next(next_time, 3.0),
on.completed(completed_time)
});
WHEN("ref_count is used"){
auto res = w.start(
[&xs]() {
return xs
.publish()
.ref_count();
},
start_created,
start_subscribed,
start_unsubscribed
);
THEN("the output contains exactly the input") {
auto required = rxu::to_vector({
on.next(next_time, 0.0),
on.next(next_time, 1.0),
on.next(next_time, 2.0),
on.next(next_time, 3.0),
on.next(next_time, 4.0),
on.next(next_time, 5.0),
on.next(next_time, 6.0),
on.next(next_time, 7.0),
on.next(next_time, 8.0),
on.next(next_time, 9.0),
on.next(next_time, 10.0),
on.completed(completed_time)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
}
WHEN("ref_count(other) is used"){
auto res = w.start(
[&xs]() {
auto published = xs.publish();
auto map_to_int = published.map([](double v) { return (long) v; });
// Ensures that 'ref_count(other)' has the source value type,
// not the publisher's value type.
auto with_ref_count = map_to_int.ref_count(published);
return with_ref_count;
},
start_created,
start_subscribed,
start_unsubscribed
);
THEN("the output contains the long-ified input") {
auto required = rxu::to_vector({
out.next(next_time, 0L),
out.next(next_time, 1L),
out.next(next_time, 2L),
out.next(next_time, 3L),
out.next(next_time, 4L),
out.next(next_time, 5L),
out.next(next_time, 6L),
out.next(next_time, 7L),
out.next(next_time, 8L),
out.next(next_time, 9L),
out.next(next_time, 10L),
out.completed(completed_time)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
}
WHEN("ref_count(other) is used in a diamond"){
auto source = rxs::range<double>(0, 3);
int published_on_next_count = 0;
auto res = w.start(
[&xs3, &published_on_next_count]() {
// Ensure we only subscribe once to 'published' when its in a diamond.
auto next = xs3.map(
[&](double v) {
published_on_next_count++;
return v;
}
);
auto published = next.publish();
// Ensures that 'x.ref_count(other)' has the 'x' value type, not the other's
// value type.
auto map_to_int = published.map([](double v) { return (long) v; });
auto left = map_to_int.map([](long v) { return v * 2; });
auto right = map_to_int.map([](long v) { return v * 100; });
auto merge = left.merge(right);
auto with_ref_count = merge.ref_count(published);
return with_ref_count;
},
start_created,
start_subscribed,
start_unsubscribed
);
THEN("the output is subscribed to only once when its in a diamond") {
// Ensure we only subscribe once to 'published' when its in a diamond.
CHECK(published_on_next_count == 4);
}
THEN("the output left,right is interleaved without being biased towards one side.") {
auto required = rxu::to_vector({
out.next(next_time, 0L),
out.next(next_time, 0L),
out.next(next_time, 2L),
out.next(next_time, 100L),
out.next(next_time, 4L),
out.next(next_time, 200L),
out.next(next_time, 6L),
out.next(next_time, 300L),
out.completed(completed_time)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
}
}
}
SCENARIO("publish basic", "[publish][multicast][subject][operators]"){
GIVEN("a test hot observable of longs"){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto xs = sc.make_hot_observable({
on.next(110, 7),
on.next(220, 3),
on.next(280, 4),
on.next(290, 1),
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(410, 13),
on.next(430, 2),
on.next(450, 9),
on.next(520, 11),
on.next(560, 20),
on.completed(600)
});
auto res = w.make_subscriber<int>();
rx::connectable_observable<int> ys;
WHEN("subscribed and then connected"){
w.schedule_absolute(rxsc::test::created_time,
[&ys, &xs](const rxsc::schedulable&){
ys = xs.publish().as_dynamic();
//ys = xs.publish_last().as_dynamic();
});
w.schedule_absolute(rxsc::test::subscribed_time,
[&ys, &res](const rxsc::schedulable&){
ys.subscribe(res);
});
w.schedule_absolute(rxsc::test::unsubscribed_time,
[&res](const rxsc::schedulable&){
res.unsubscribe();
});
{
rx::composite_subscription connection;
w.schedule_absolute(300,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(400,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
{
rx::composite_subscription connection;
w.schedule_absolute(500,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(550,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
{
rx::composite_subscription connection;
w.schedule_absolute(650,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(800,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
w.start();
THEN("the output only contains items sent while subscribed"){
auto required = rxu::to_vector({
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(520, 11)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
THEN("there were 3 subscription/unsubscription"){
auto required = rxu::to_vector({
on.subscribe(300, 400),
on.subscribe(500, 550),
on.subscribe(650, 800)
});
auto actual = xs.subscriptions();
REQUIRE(required == actual);
}
}
}
}
SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){
GIVEN("a test hot observable of longs"){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
std::runtime_error ex("publish on_error");
auto xs = sc.make_hot_observable({
on.next(110, 7),
on.next(220, 3),
on.next(280, 4),
on.next(290, 1),
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(410, 13),
on.next(430, 2),
on.next(450, 9),
on.next(520, 11),
on.next(560, 20),
on.error(600, ex)
});
auto res = w.make_subscriber<int>();
rx::connectable_observable<int> ys;
WHEN("subscribed and then connected"){
w.schedule_absolute(rxsc::test::created_time,
[&ys, &xs](const rxsc::schedulable&){
ys = xs.publish().as_dynamic();
});
w.schedule_absolute(rxsc::test::subscribed_time,
[&ys, &res](const rxsc::schedulable&){
ys.subscribe(res);
});
w.schedule_absolute(rxsc::test::unsubscribed_time,
[&res](const rxsc::schedulable&){
res.unsubscribe();
});
{
rx::composite_subscription connection;
w.schedule_absolute(300,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(400,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
{
rx::composite_subscription connection;
w.schedule_absolute(500,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(800,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
w.start();
THEN("the output only contains items sent while subscribed"){
auto required = rxu::to_vector({
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(520, 11),
on.next(560, 20),
on.error(600, ex)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
THEN("there were 3 subscription/unsubscription"){
auto required = rxu::to_vector({
on.subscribe(300, 400),
on.subscribe(500, 600)
});
auto actual = xs.subscriptions();
REQUIRE(required == actual);
}
}
}
}
SCENARIO("publish basic with initial value", "[publish][multicast][behavior][operators]"){
GIVEN("a test hot observable of longs"){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto xs = sc.make_hot_observable({
on.next(110, 7),
on.next(220, 3),
on.next(280, 4),
on.next(290, 1),
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(410, 13),
on.next(430, 2),
on.next(450, 9),
on.next(520, 11),
on.next(560, 20),
on.completed(600)
});
auto res = w.make_subscriber<int>();
rx::connectable_observable<int> ys;
WHEN("subscribed and then connected"){
w.schedule_absolute(rxsc::test::created_time,
[&ys, &xs](const rxsc::schedulable&){
ys = xs.publish(1979).as_dynamic();
});
w.schedule_absolute(rxsc::test::subscribed_time,
[&ys, &res](const rxsc::schedulable&){
ys.subscribe(res);
});
w.schedule_absolute(rxsc::test::unsubscribed_time,
[&res](const rxsc::schedulable&){
res.unsubscribe();
});
{
rx::composite_subscription connection;
w.schedule_absolute(300,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(400,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
{
rx::composite_subscription connection;
w.schedule_absolute(500,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(550,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
{
rx::composite_subscription connection;
w.schedule_absolute(650,
[connection, &ys](const rxsc::schedulable&){
ys.connect(connection);
});
w.schedule_absolute(800,
[connection](const rxsc::schedulable&){
connection.unsubscribe();
});
}
w.start();
THEN("the output only contains items sent while subscribed"){
auto required = rxu::to_vector({
on.next(200, 1979),
on.next(340, 8),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(520, 11)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
THEN("there were 3 subscription/unsubscription"){
auto required = rxu::to_vector({
on.subscribe(300, 400),
on.subscribe(500, 550),
on.subscribe(650, 800)
});
auto actual = xs.subscriptions();
REQUIRE(required == actual);
}
}
}
}
| 34.259887 | 97 | 0.445031 | Capstone-S13 |
4b60e237f32d8903ee202101513eabbd349fab27 | 352 | cpp | C++ | src/core/aa_clip.cpp | nicelbole/skia.c | ce60902da5768973316075917e347d5f61097e74 | [
"Apache-2.0"
] | null | null | null | src/core/aa_clip.cpp | nicelbole/skia.c | ce60902da5768973316075917e347d5f61097e74 | [
"Apache-2.0"
] | null | null | null | src/core/aa_clip.cpp | nicelbole/skia.c | ce60902da5768973316075917e347d5f61097e74 | [
"Apache-2.0"
] | null | null | null | AAClip* create_aa_clip()
{
AAClip *clip = malloc(sizeof(AAClip));
clip->bounds.setEmpty();
clip->run_head = nullptr;
return clip;
}
AAClip* create_aa_clip(const AAClip& src)
{
AAClip* clip = malloc(sizeof(AAClip));
clip->run_head = nullptr;
*clip = src;
return clip;
}
void delete_aa_clip(AAClip* clip)
{
free_runs_aa_clip(clip);
}
| 16.761905 | 41 | 0.6875 | nicelbole |
4b610bec63b9e74ff0100d2707996f2b72a7c074 | 2,892 | cpp | C++ | src/mongo/db/pipeline/accumulator.cpp | wentingwang/morphus | af40299a5f07fd3157946112738f602a566a9908 | [
"Apache-2.0"
] | 24 | 2015-10-15T00:03:57.000Z | 2021-04-25T18:21:31.000Z | src/mongo/db/pipeline/accumulator.cpp | stennie/mongo | 9ff44ae9ad16a70e49517a78279260a37d31ac7c | [
"Apache-2.0"
] | 1 | 2015-06-02T12:19:19.000Z | 2015-06-02T12:19:19.000Z | src/mongo/db/pipeline/accumulator.cpp | stennie/mongo | 9ff44ae9ad16a70e49517a78279260a37d31ac7c | [
"Apache-2.0"
] | 3 | 2017-07-26T11:17:11.000Z | 2021-11-30T00:11:32.000Z | /**
* Copyright (c) 2011 10gen Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "pch.h"
#include "db/pipeline/accumulator.h"
#include "db/jsobj.h"
#include "util/mongoutils/str.h"
namespace mongo {
using namespace mongoutils;
void Accumulator::addOperand(
const intrusive_ptr<Expression> &pExpression) {
uassert(15943, str::stream() << "group accumulator " <<
getOpName() << " only accepts one operand",
vpOperand.size() < 1);
ExpressionNary::addOperand(pExpression);
}
Accumulator::Accumulator():
ExpressionNary() {
}
void Accumulator::opToBson(BSONObjBuilder *pBuilder, StringData opName,
StringData fieldName, bool requireExpression) const {
verify(vpOperand.size() == 1);
BSONObjBuilder builder;
vpOperand[0]->addToBsonObj(&builder, opName, requireExpression);
pBuilder->append(fieldName, builder.done());
}
void Accumulator::addToBsonObj(BSONObjBuilder *pBuilder,
StringData fieldName,
bool requireExpression) const {
opToBson(pBuilder, getOpName(), fieldName, requireExpression);
}
void Accumulator::addToBsonArray(BSONArrayBuilder *pBuilder) const {
verify(false); // these can't appear in arrays
}
void agg_framework_reservedErrors() {
uassert(16030, "reserved error", false);
uassert(16031, "reserved error", false);
uassert(16032, "reserved error", false);
uassert(16033, "reserved error", false);
uassert(16036, "reserved error", false);
uassert(16037, "reserved error", false);
uassert(16038, "reserved error", false);
uassert(16039, "reserved error", false);
uassert(16040, "reserved error", false);
uassert(16041, "reserved error", false);
uassert(16042, "reserved error", false);
uassert(16043, "reserved error", false);
uassert(16044, "reserved error", false);
uassert(16045, "reserved error", false);
uassert(16046, "reserved error", false);
uassert(16047, "reserved error", false);
uassert(16048, "reserved error", false);
uassert(16049, "reserved error", false);
}
}
| 36.607595 | 84 | 0.641425 | wentingwang |
b49ee02b8dfc79ea768391b51d38ec4b44863f61 | 2,412 | cc | C++ | leetcode/ds_list_missing_number.cc | prashrock/C- | 3ed46815d40b3e42cd9f36d23c8ee2a9de742323 | [
"MIT"
] | 1 | 2016-12-05T10:42:46.000Z | 2016-12-05T10:42:46.000Z | leetcode/ds_list_missing_number.cc | prashrock/CPP | 3ed46815d40b3e42cd9f36d23c8ee2a9de742323 | [
"MIT"
] | null | null | null | leetcode/ds_list_missing_number.cc | prashrock/CPP | 3ed46815d40b3e42cd9f36d23c8ee2a9de742323 | [
"MIT"
] | null | null | null | //g++-5 --std=c++11 -Wall -g -o ds_list_missing_number ds_list_missing_number.cc
/**
* @file Find Missing Number from Array
* @brief Given array containing n distinct integers [0, n) find missing integer
*/
// https://leetcode.com/problems/missing-number/
#include <iostream> /* std::cout */
#include <iomanip> /* std::setw */
#include <cmath> /* pow */
#include <cassert> /* assert */
#include <algorithm> /* std::max */
#include <vector> /* std::vector */
#include <string> /* std::string, */
#include <cstring> /* std::strtok */
#include <unordered_map> /* std::unordered_map container */
using namespace std;
/**
* Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find
* the one that is missing from the array.
* For example,
* Given nums = [0, 1, 3] return 2.
* Note:
* Your algorithm should run in linear runtime complexity. Could you implement it
* using only constant extra space complexity?
*/
/* Since numbers are in a specific sequence [0, n), use AP *
* to deduce what should be the total of all numbers. Next *
* subtract this from observed total to find missing elem */
int missingNumber(vector<int>& nums) {
/* sum of n numbers (1, 2, 3, ... n) = n(n+1)/2. *
* Handle 0 as a spl case */
int n = nums.size();
unsigned long obs_sum = 0, calc_sum = n * (n + 1) / 2;
for(int i = 0; i < (int)nums.size(); ++i) obs_sum += nums[i];
return calc_sum - obs_sum;
}
int main()
{
int ans, exp;
vector<int> nums;
nums = {0}; exp = 1;
ans = missingNumber(nums);
if(ans != exp) goto Errmain;
nums = {1}; exp = 0;
ans = missingNumber(nums);
if(ans != exp) goto Errmain;
nums = {5, 4, 6, 3, 1, 2}; exp = 0;
ans = missingNumber(nums);
if(ans != exp) goto Errmain;
nums = {5, 0, 6, 3, 1, 2}; exp = 4;
ans = missingNumber(nums);
if(ans != exp) goto Errmain;
cout << "All test-cases passed." << endl;
return 0;
Errmain:
cout << "Error: Missing Integer failed for - ";
for(auto val: nums) cout << val << ", "; cout << endl;
cout << "Expected = " << exp << " Got = " << ans << endl;
return -1;
}
| 33.5 | 81 | 0.538972 | prashrock |
b49f395cef0e4b108b73c6ae583ef37eff3d02eb | 4,137 | cpp | C++ | Vendor/Include/bullet/BulletCollision/Gimpact/btContactProcessing.cpp | allogic/Redshift | 4606267b53e3d094ba588acb9ceaa97e3289632b | [
"MIT"
] | null | null | null | Vendor/Include/bullet/BulletCollision/Gimpact/btContactProcessing.cpp | allogic/Redshift | 4606267b53e3d094ba588acb9ceaa97e3289632b | [
"MIT"
] | null | null | null | Vendor/Include/bullet/BulletCollision/Gimpact/btContactProcessing.cpp | allogic/Redshift | 4606267b53e3d094ba588acb9ceaa97e3289632b | [
"MIT"
] | null | null | null |
/*
This source file is part of GIMPACT Library.
For the latest info, see http://gimpact.sourceforge.net/
Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
email: [email protected]
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include <bullet/BulletCollision/Gimpact/btContactProcessing.h>
#define MAX_COINCIDENT 8
struct CONTACT_KEY_TOKEN
{
unsigned int m_key;
int m_value;
CONTACT_KEY_TOKEN()
{
}
CONTACT_KEY_TOKEN(unsigned int key, int token)
{
m_key = key;
m_value = token;
}
CONTACT_KEY_TOKEN(const CONTACT_KEY_TOKEN& rtoken)
{
m_key = rtoken.m_key;
m_value = rtoken.m_value;
}
inline bool operator<(const CONTACT_KEY_TOKEN& other) const
{
return (m_key < other.m_key);
}
inline bool operator>(const CONTACT_KEY_TOKEN& other) const
{
return (m_key > other.m_key);
}
};
class CONTACT_KEY_TOKEN_COMP
{
public:
bool operator()(const CONTACT_KEY_TOKEN& a, const CONTACT_KEY_TOKEN& b) const
{
return (a < b);
}
};
void btContactArray::merge_contacts(
const btContactArray& contacts, bool normal_contact_average)
{
clear();
int i;
if (contacts.size() == 0) return;
if (contacts.size() == 1)
{
push_back(contacts[0]);
return;
}
btAlignedObjectArray<CONTACT_KEY_TOKEN> keycontacts;
keycontacts.reserve(contacts.size());
//fill key contacts
for (i = 0; i < contacts.size(); i++)
{
keycontacts.push_back(CONTACT_KEY_TOKEN(contacts[i].calc_key_contact(), i));
}
//sort keys
keycontacts.quickSort(CONTACT_KEY_TOKEN_COMP());
// Merge contacts
int coincident_count = 0;
btVector3 coincident_normals[MAX_COINCIDENT];
unsigned int last_key = keycontacts[0].m_key;
unsigned int key = 0;
push_back(contacts[keycontacts[0].m_value]);
GIM_CONTACT* pcontact = &(*this)[0];
for (i = 1; i < keycontacts.size(); i++)
{
key = keycontacts[i].m_key;
const GIM_CONTACT* scontact = &contacts[keycontacts[i].m_value];
if (last_key == key) //same points
{
//merge contact
if (pcontact->m_depth - CONTACT_DIFF_EPSILON > scontact->m_depth) //)
{
*pcontact = *scontact;
coincident_count = 0;
}
else if (normal_contact_average)
{
if (btFabs(pcontact->m_depth - scontact->m_depth) < CONTACT_DIFF_EPSILON)
{
if (coincident_count < MAX_COINCIDENT)
{
coincident_normals[coincident_count] = scontact->m_normal;
coincident_count++;
}
}
}
}
else
{ //add new contact
if (normal_contact_average && coincident_count > 0)
{
pcontact->interpolate_normals(coincident_normals, coincident_count);
coincident_count = 0;
}
push_back(*scontact);
pcontact = &(*this)[this->size() - 1];
}
last_key = key;
}
}
void btContactArray::merge_contacts_unique(const btContactArray& contacts)
{
clear();
if (contacts.size() == 0) return;
if (contacts.size() == 1)
{
push_back(contacts[0]);
return;
}
GIM_CONTACT average_contact = contacts[0];
for (int i = 1; i < contacts.size(); i++)
{
average_contact.m_point += contacts[i].m_point;
average_contact.m_normal += contacts[i].m_normal * contacts[i].m_depth;
}
//divide
btScalar divide_average = 1.0f / ((btScalar)contacts.size());
average_contact.m_point *= divide_average;
average_contact.m_normal *= divide_average;
average_contact.m_depth = average_contact.m_normal.length();
average_contact.m_normal /= average_contact.m_depth;
}
| 23.505682 | 243 | 0.719604 | allogic |
b49fb7d26b8c0162262044733b2279cbcbf30db6 | 823 | cpp | C++ | construct-binary-tree-from-preorder-and-inorder/main.cpp | rickytan/LeetCode | 7df9a47928552babaf5d2abf1d153bd92d44be09 | [
"MIT"
] | 1 | 2015-04-04T18:32:31.000Z | 2015-04-04T18:32:31.000Z | construct-binary-tree-from-preorder-and-inorder/main.cpp | rickytan/LeetCode | 7df9a47928552babaf5d2abf1d153bd92d44be09 | [
"MIT"
] | null | null | null | construct-binary-tree-from-preorder-and-inorder/main.cpp | rickytan/LeetCode | 7df9a47928552babaf5d2abf1d153bd92d44be09 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
public:
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
if (inorder.empty())
return NULL;
int value = preorder[0];
preorder.erase(preorder.begin());
TreeNode *root = new TreeNode(value);
vector<int>::iterator index = std::find(inorder.begin(), inorder.end(), value);
vector<int> left(inorder.begin(), index);
root->left = buildTree(preorder, left);
vector<int> right(index + 1, inorder.end());
root->right = buildTree(preorder, right);
return root;
}
};
int main()
{
}
| 22.861111 | 87 | 0.602673 | rickytan |
b4a4f274283ff435bf2e8f4a7db55a429580833e | 1,229 | cpp | C++ | tests/unit/src/get_all_widgets.cpp | igagis/morda | dd7b58f7cb2689d56b7796cc9b6b9302aad1a529 | [
"MIT"
] | 69 | 2016-12-07T05:56:53.000Z | 2020-11-27T20:59:05.000Z | tests/unit/src/get_all_widgets.cpp | igagis/morda | dd7b58f7cb2689d56b7796cc9b6b9302aad1a529 | [
"MIT"
] | 103 | 2015-07-10T14:42:21.000Z | 2020-09-09T16:16:21.000Z | tests/unit/src/get_all_widgets.cpp | igagis/morda | dd7b58f7cb2689d56b7796cc9b6b9302aad1a529 | [
"MIT"
] | 18 | 2016-11-22T14:41:37.000Z | 2020-04-22T18:16:10.000Z | #include <tst/set.hpp>
#include <tst/check.hpp>
#include <morda/gui.hpp>
#include <morda/widgets/group/column.hpp>
#include "../../harness/util/dummy_context.hpp"
namespace{
tst::set set("get_all_widgets", [](tst::suite& suite){
suite.add("get_all_widgets_function", []{
morda::gui m(make_dummy_context());
auto w = m.context->inflater.inflate(treeml::read(R"qwertyuiop(
@container{
@column{
id{1}
}
@column{
id{2}
@column{
id{3}
}
@row{
id{4}
@pile{
id{8}
@column{
id{9}
}
}
}
}
@pile{
id{5}
@column{
id{6}
@row{
id{7}
}
}
}
}
)qwertyuiop"));
std::vector<std::string> expected_ids = {{
"1", "2", "3", "6", "9"
}};
tst::check(w != nullptr, SL);
auto aaas = w->get_all_widgets<morda::column>();
tst::check_ne(aaas.size(), size_t(0), SL);
for(const auto& id : expected_ids){
auto i = std::find_if(
aaas.begin(),
aaas.end(),
[&id](const decltype(aaas)::value_type& wg) -> bool {
return wg->id == id;
}
);
tst::check(i != aaas.end(), SL) << "id = '" << id <<"' not found";
}
});
});
}
| 16.835616 | 78 | 0.498779 | igagis |
b4a7433fbd7f183050b4626f558d7b32054c877f | 2,437 | cc | C++ | rtc_base/testutils.cc | airmelody5211/webrtc-clone | 943843f1da42e47668c22ca758830334167f1b17 | [
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | rtc_base/testutils.cc | zhangj1024/webrtc | 3a6b729a8edaabd2fe324e1f6f830869ec38d5ab | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | rtc_base/testutils.cc | zhangj1024/webrtc | 3a6b729a8edaabd2fe324e1f6f830869ec38d5ab | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | /*
* Copyright 2007 The WebRTC 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 in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "rtc_base/testutils.h"
namespace webrtc {
namespace testing {
StreamSink::StreamSink() = default;
StreamSink::~StreamSink() = default;
StreamSource::StreamSource() {
Clear();
}
StreamSource::~StreamSource() = default;
StreamState StreamSource::GetState() const {
return state_;
}
StreamResult StreamSource::Read(void* buffer,
size_t buffer_len,
size_t* read,
int* error) {
if (SS_CLOSED == state_) {
if (error)
*error = -1;
return SR_ERROR;
}
if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
return SR_BLOCK;
}
size_t count = std::min(buffer_len, readable_data_.size() - read_block_);
memcpy(buffer, &readable_data_[0], count);
size_t new_size = readable_data_.size() - count;
// Avoid undefined access beyond the last element of the vector.
// This only happens when new_size is 0.
if (count < readable_data_.size()) {
memmove(&readable_data_[0], &readable_data_[count], new_size);
}
readable_data_.resize(new_size);
if (read)
*read = count;
return SR_SUCCESS;
}
StreamResult StreamSource::Write(const void* data,
size_t data_len,
size_t* written,
int* error) {
if (SS_CLOSED == state_) {
if (error)
*error = -1;
return SR_ERROR;
}
if (SS_OPENING == state_) {
return SR_BLOCK;
}
if (SIZE_UNKNOWN != write_block_) {
if (written_data_.size() >= write_block_) {
return SR_BLOCK;
}
if (data_len > (write_block_ - written_data_.size())) {
data_len = write_block_ - written_data_.size();
}
}
if (written)
*written = data_len;
const char* cdata = static_cast<const char*>(data);
written_data_.insert(written_data_.end(), cdata, cdata + data_len);
return SR_SUCCESS;
}
void StreamSource::Close() {
state_ = SS_CLOSED;
}
} // namespace testing
} // namespace webrtc
| 27.382022 | 75 | 0.629462 | airmelody5211 |
b4a756dcb85a3911a1482af0b3334cc0e585488d | 243 | cpp | C++ | libs/core/render/src/bksge_core_render_frame_buffer.cpp | myoukaku/bksge | 0f8b60e475a3f1709723906e4796b5e60decf06e | [
"MIT"
] | 4 | 2018-06-10T13:35:32.000Z | 2021-06-03T14:27:41.000Z | libs/core/render/src/bksge_core_render_frame_buffer.cpp | myoukaku/bksge | 0f8b60e475a3f1709723906e4796b5e60decf06e | [
"MIT"
] | 566 | 2017-01-31T05:36:09.000Z | 2022-02-09T05:04:37.000Z | libs/core/render/src/bksge_core_render_frame_buffer.cpp | myoukaku/bksge | 0f8b60e475a3f1709723906e4796b5e60decf06e | [
"MIT"
] | 1 | 2018-07-05T04:40:53.000Z | 2018-07-05T04:40:53.000Z | /**
* @file bksge_core_render_frame_buffer.cpp
*
* @brief FrameBuffer の実装
*
* @author myoukaku
*/
#include <bksge/fnd/config.hpp>
#if !defined(BKSGE_HEADER_ONLY)
#include <bksge/core/render/inl/frame_buffer_inl.hpp>
#endif
| 18.692308 | 54 | 0.695473 | myoukaku |
b4aa9cc7048eb0c33ed984dc932031a41f2588b7 | 99,824 | cpp | C++ | src/urAPI.cpp | jongwook/urMus | b3d22e8011253f137a3581e84db8e79accccc7a4 | [
"MIT",
"AML",
"BSD-3-Clause"
] | 1 | 2015-11-05T00:50:07.000Z | 2015-11-05T00:50:07.000Z | src/urAPI.cpp | jongwook/urMus | b3d22e8011253f137a3581e84db8e79accccc7a4 | [
"MIT",
"AML",
"BSD-3-Clause"
] | null | null | null | src/urAPI.cpp | jongwook/urMus | b3d22e8011253f137a3581e84db8e79accccc7a4 | [
"MIT",
"AML",
"BSD-3-Clause"
] | null | null | null | /*
* urAPI.c
* urMus
*
* Created by Georg Essl on 6/20/09.
* Copyright 2009 Georg Essl. All rights reserved. See LICENSE.txt for license details.
*
*/
#include "urAPI.h"
#include "urGraphics.h"
#include "MachTimer.h"
//TODO//#include "RIOAudioUnitLayer.h"
#include "urSound.h"
#include "httpServer.h"
// Make EAGLview global so lua interface can grab it without breaking a leg over IMP
#ifdef TARGET_IPHONE
extern EAGLView* g_glView;
#endif
// This is to transport error and print messages to EAGLview
extern string errorstr;
extern bool newerror;
// Global lua state
lua_State *lua;
// Region based API below, this is inspired by WoW's frame API with many modifications and expansions.
// Our engine supports paging, region horizontal and vertical scrolling, full multi-touch and more.
// Hardcoded for now... lazy me
#define MAX_PAGES 30
int currentPage;
urAPI_Region_t* firstRegion[MAX_PAGES] = {nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil};
urAPI_Region_t* lastRegion[MAX_PAGES] = {nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil};
int numRegions[MAX_PAGES] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
urAPI_Region_t* UIParent = nil;
ursAPI_FlowBox_t* FBNope = nil;
MachTimer* systimer;
const char DEFAULT_RPOINT[] = "BOTTOMLEFT";
#define STRATA_PARENT 0
#define STRATA_BACKGROUND 1
#define STRATA_LOW 2
#define STRATA_MEDIUM 3
#define STRATA_HIGH 4
#define STRATA_DIALOG 5
#define STRATA_FULLSCREEN 6
#define STRATA_FULLSCREEN_DIALOG 7
#define STRATA_TOOLTIP 8
#define LAYER_BACKGROUND 1
#define LAYER_BORDER 2
#define LAYER_ARTWORK 3
#define LAYER_OVERLAY 4
#define LAYER_HIGHLIGHT 5
urAPI_Region_t* findRegionHit(float x, float y)
{
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil /* && t != firstRegion[currentPage] */; t=t->prev)
{
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height && t->isTouchEnabled)
if(t->isClipping==false || (x >= t->clipleft && x <= t->clipleft+t->clipwidth &&
y >= t->clipbottom && y <= t->clipbottom+t->clipheight))
return t;
}
return nil;
}
void callAllOnLeaveRegions(float x, float y)
{
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil ; t=t->prev)
{
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height
&& t->OnLeave != 0)
if(t->isClipping==false || (x >= t->clipleft && x <= t->clipleft+t->clipwidth &&
y >= t->clipbottom && y <= t->clipbottom+t->clipheight))
{
t->entered = false;
callScript(t->OnLeave, t);
}
}
}
void callAllOnEnterLeaveRegions(int nr, float* x, float* y, float* ox, float* oy)
{
bool didenter;
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil /* && t != firstRegion[currentPage] */; t=t->prev)
{
for(int i=0; i<nr; i++)
{
if(!(x[i] >= t->left && x[i] <= t->left+t->width &&
y[i] >= t->bottom && y[i] <= t->bottom+t->height) &&
ox[i] >= t->left && ox[i] <= t->left+t->width &&
oy[i] >= t->bottom && oy[i] <= t->bottom+t->height
&& t->OnLeave != 0)
{
// if(t->entered)
// {
t->entered = false;
callScript(t->OnLeave, t);
// }
// else
// {
// int a=0;
// }
}
else if(x[i] >= t->left && x[i] <= t->left+t->width &&
y[i] >= t->bottom && y[i] <= t->bottom+t->height &&
(!(ox[i] >= t->left && ox[i] <= t->left+t->width &&
oy[i] >= t->bottom && oy[i] <= t->bottom+t->height) || !t->entered)
&& t->OnEnter != 0)
{
// didenter = true;
// if(!t->entered)
// {
t->entered = true;
callScript(t->OnEnter, t);
// }
// else
// {
// int a=0;
// }
}
}
// if(t->entered && !didenter)
// {
// t->entered = false;
// callScript(t->OnLeave, t);
// }
// didenter = false;
}
}
urAPI_Region_t* findRegionDraggable(float x, float y)
{
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil /* && t != firstRegion[currentPage]*/; t=t->prev)
{
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height && t->isMovable && t->isTouchEnabled)
if(t->isClipping==false || (x >= t->clipleft && x <= t->clipleft+t->clipwidth &&
y >= t->clipbottom && y <= t->clipbottom+t->clipheight))
return t;
}
return nil;
}
urAPI_Region_t* findRegionXScrolled(float x, float y, float dx)
{
if(fabs(dx) > 0.9)
{
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil /* && t != firstRegion[currentPage]*/; t=t->prev)
{
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height && t->isScrollXEnabled && t->isTouchEnabled)
if(t->isClipping==false || (x >= t->clipleft && x <= t->clipleft+t->clipwidth &&
y >= t->clipbottom && y <= t->clipbottom+t->clipheight))
return t;
}
}
return nil;
}
urAPI_Region_t* findRegionYScrolled(float x, float y, float dy)
{
if(fabs(dy) > 0.9*3)
{
for(urAPI_Region_t* t=lastRegion[currentPage]; t != nil /* && t != firstRegion[currentPage]*/; t=t->prev)
{
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height && t->isScrollYEnabled && t->isTouchEnabled)
if(t->isClipping==false || (x >= t->clipleft && x <= t->clipleft+t->clipwidth &&
y >= t->clipbottom && y <= t->clipbottom+t->clipheight))
return t;
}
}
return nil;
}
void layoutchildren(urAPI_Region_t* region)
{
urAPI_Region_t* child = region->firstchild;
while(child!=NULL)
{
child->update = true;
layout(child);
child = child->nextchild;
}
}
bool visibleparent(urAPI_Region_t* region)
{
if(region == UIParent)
return true;
urAPI_Region_t* parent = region->parent;
while(parent != UIParent && parent->isVisible == true)
{
parent = parent->parent;
}
if(parent == UIParent)
return true;
else
return false;
}
void showchildren(urAPI_Region_t* region)
{
urAPI_Region_t* child = region->firstchild;
while(child!=NULL)
{
if(child->isShown)
{
child->isVisible = true;
if(region->OnShow != 0)
callScript(region->OnShow, region);
showchildren(child);
}
child = child->nextchild;
}
}
void hidechildren(urAPI_Region_t* region)
{
urAPI_Region_t* child = region->firstchild;
while(child!=NULL)
{
if(child->isVisible)
{
child->isVisible = false;
if(region->OnHide != 0)
callScript(region->OnHide, region);
hidechildren(child);
}
child = child->nextchild;
}
}
// This function is heavily informed by Jerry's base.lua in wowsim function, which is covered by a BSD-style (open) license.
// (EDIT) Fixed it up. Was buggy as is and didn't properly align for most anchor sides.
bool layout(urAPI_Region_t* region)
{
if(region == nil) return false;
bool update = region->update;
if(!update)
{
if(region->relativeRegion)
update = layout(region->relativeRegion);
else
update = layout(region->parent);
}
if(!update) return false;
float left, right, top, bottom, width, height, cx, cy,x,y;
left = right = top = bottom = width = height = cx = cy = x = y = -1000000;
const char* point = region->point;
if(point == nil)
point = DEFAULT_RPOINT;
urAPI_Region_t* relativeRegion = region->relativeRegion;
if(relativeRegion == nil)
relativeRegion = region->parent;
if(relativeRegion == nil)
relativeRegion = UIParent; // This should be another layer but we don't care for now
const char* relativePoint = region->relativePoint;
if(relativePoint == nil)
relativePoint = DEFAULT_RPOINT;
if(!strcmp(relativePoint, "ALL"))
{
left = relativeRegion->left;
bottom = relativeRegion->bottom;
width = relativeRegion->width;
height = relativeRegion->height;
}
else if(!strcmp(relativePoint,"TOPLEFT"))
{
x = relativeRegion->left;
y = relativeRegion->top;
}
else if(!strcmp(relativePoint,"TOPRIGHT"))
{
x = relativeRegion->right;
y = relativeRegion->top;
}
else if(!strcmp(relativePoint,"TOP"))
{
x = relativeRegion->cx;
y = relativeRegion->top;
}
else if(!strcmp(relativePoint,"LEFT"))
{
x = relativeRegion->left;
y = relativeRegion->cy;
}
else if(!strcmp(relativePoint,"RIGHT"))
{
x = relativeRegion->right;
y = relativeRegion->cy;
}
else if(!strcmp(relativePoint,"CENTER"))
{
x = relativeRegion->cx;
y = relativeRegion->cy;
}
else if(!strcmp(relativePoint,"BOTTOMLEFT"))
{
x = relativeRegion->left;
y = relativeRegion->bottom;
}
else if(!strcmp(relativePoint,"BOTTOMRIGHT"))
{
x = relativeRegion->right;
y = relativeRegion->bottom;
}
else if(!strcmp(relativePoint,"BOTTOM"))
{
x = relativeRegion->cx;
y = relativeRegion->bottom;
}
else
{
// Error!!
luaL_error(lua, "Unknown relativePoint when layouting regions.");
return false;
}
x = x+region->ofsx;
y = y+region->ofsy;
if(!strcmp(point,"TOPLEFT"))
{
left = x;
top = y;
}
else if(!strcmp(point,"TOPRIGHT"))
{
right = x;
top = y;
}
else if(!strcmp(point,"TOP"))
{
cx = x;
top = y;
}
else if(!strcmp(point,"LEFT"))
{
left = x;
cy = y; // Another typo here
}
else if(!strcmp(point,"RIGHT"))
{
right = x;
cy = y;
}
else if(!strcmp(point,"CENTER"))
{
cx = x;
cy = y;
}
else if(!strcmp(point,"BOTTOMLEFT"))
{
left = x;
bottom = y;
}
else if(!strcmp(point,"BOTTOMRIGHT"))
{
right = x;
bottom = y;
}
else if(!strcmp(point,"BOTTOM"))
{
cx = x;
bottom = y;
}
else
{
// Error!!
luaL_error(lua, "Unknown relativePoint when layouting regions.");
return false;
}
if(left > 0 && right > 0)
{
width = right - left;
}
if(top > 0 && bottom > 0)
{
height = top - bottom;
}
if(width == -1000000 && region->width > 0) width = region->width;
if(height == -1000000 && region->height > 0) height = region->height;
if(left == -1000000 && width > 0)
{
if(right>0) left = right - width;
else if(cx>0)
{
left = cx - width/2; // This was buggy. Fixing it up.
right = cx + width/2;
}
}
if(bottom == -1000000 && height > 0)
{
if(top>0) bottom = top - height;
if(cy>0)
{
bottom = cy - height/2; // This was buggy. Fixing it up.
top = cy + height/2;
}
}
update = false;
if(left != region->left || bottom != region->bottom || width != region->width || height != region->height)
update = true;
region->left = left;
region->bottom = bottom;
region->width = width;
region->height = height;
region->cx = left + width/2;
region->cy = bottom + height/2;
top = bottom + height; // All this was missing with bad effects
region->top = top;
right = left + width;
region->right = right;
region->update = false;
if(update)
{
layoutchildren(region);
// callScript("OnSizeChanged", width, height)
}
return update;
}
//------------------------------------------------------------------------------
// Our custom lua API
//------------------------------------------------------------------------------
static urAPI_Region_t *checkregion(lua_State *lua, int nr)
{
// void *region = luaL_checkudata(lua, nr, "URAPI.region");
luaL_checktype(lua, nr, LUA_TTABLE);
lua_rawgeti(lua, nr, 0);
void *region = lua_touserdata(lua, -1);
lua_pop(lua,1);
luaL_argcheck(lua, region!= NULL, nr, "'region' expected");
return (urAPI_Region_t*)region;
}
static urAPI_Texture_t *checktexture(lua_State *lua, int nr)
{
void *texture = luaL_checkudata(lua, nr, "URAPI.texture");
luaL_argcheck(lua, texture!= NULL, nr, "'texture' expected");
return (urAPI_Texture_t*)texture;
}
static urAPI_TextLabel_t *checktextlabel(lua_State *lua, int nr)
{
void *textlabel = luaL_checkudata(lua, nr, "URAPI.textlabel");
luaL_argcheck(lua, textlabel!= NULL, nr, "'textlabel' expected");
return (urAPI_TextLabel_t*)textlabel;
}
static ursAPI_FlowBox_t *checkflowbox(lua_State *lua, int nr)
{
luaL_checktype(lua, nr, LUA_TTABLE);
lua_rawgeti(lua, nr, 0);
void *flowbox = lua_touserdata(lua, -1);
lua_pop(lua,1);
luaL_argcheck(lua, flowbox!= NULL, nr, "'flowbox' expected");
return (ursAPI_FlowBox_t*)flowbox;
}
// NEW!!
static int l_NumRegions(lua_State *lua)
{
lua_pushnumber(lua, numRegions[currentPage]);
return 1;
}
static int l_EnumerateRegions(lua_State *lua)
{
urAPI_Region_t* region;
if(lua_isnil(lua,1))
{
region = UIParent->next;
}
else
{
region = checkregion(lua,1);
if(region!=nil)
region = region->next;
}
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
return 1;
}
// Region events to support
// OnDragStart
// OnDragStop
// OnEnter
// OnEvent
// OnHide
// OnLeave
// OnTouchDown
// OnTouchUp
// OnReceiveDrag (NYI)
// OnShow
// OnSizeChanged
// OnUpdate
// OnDoubleTap (UR!)
bool callAllOnUpdate(float time)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnUpdate != 0)
callScriptWith1Args(t->OnUpdate, t,time);
}
return true;
}
bool callAllOnPageEntered(float page)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnPageEntered != 0)
callScriptWith1Args(t->OnPageEntered, t,page);
}
return true;
}
bool callAllOnPageLeft(float page)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnPageLeft != 0)
callScriptWith1Args(t->OnPageLeft, t,page);
}
return true;
}
bool callAllOnLocation(float latitude, float longitude)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnLocation != 0)
callScriptWith2Args(t->OnLocation,t,latitude, longitude);
}
return true;
}
bool callAllOnHeading(float x, float y, float z, float north)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnHeading != 0)
callScriptWith4Args(t->OnHeading,t,x,y,z,north);
}
return true;
}
bool callAllOnAccelerate(float x, float y, float z)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnAccelerate != 0)
callScriptWith3Args(t->OnAccelerate,t,x,y,z);
}
return true;
}
bool callAllOnNetIn(float a)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnNetIn != 0)
callScriptWith1Args(t->OnNetIn,t,a);
}
return true;
}
bool callAllOnNetConnect(const char* name)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnNetConnect != 0)
callScriptWith1String(t->OnNetConnect,t,name);
}
return true;
}
bool callAllOnNetDisconnect(const char* name)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnNetDisconnect != 0)
callScriptWith1String(t->OnNetDisconnect,t,name);
}
return true;
}
#ifdef SANDWICH_SUPPORT
bool callAllOnPressure(float p)
{
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnPressure != 0)
callScriptWith1Args(t->OnPressure,t,p);
}
return true;
}
#endif
bool callAllOnMicrophone(SInt32* mic_buffer, UInt32 bufferlen)
{
lua_getglobal(lua, "urMicData");
if(lua_isnil(lua, -1) || !lua_istable(lua,-1)) // Channel doesn't exist or is falsely set up
{
lua_pop(lua,1);
return false;
}
for(UInt32 i=0;i<bufferlen; i++)
{
lua_pushnumber(lua, mic_buffer[i]);
lua_rawseti(lua, -2, i+1);
}
lua_setglobal(lua, "urMicData");
for(urAPI_Region_t* t=firstRegion[currentPage]; t != nil; t=t->next)
{
if(t->OnMicrophone != 0)
callScriptWith1Global(t->OnMicrophone, t, "urMicData");
}
return true;
}
bool callScriptWith4Args(int func_ref, urAPI_Region_t* region, float a, float b, float c, float d)
{
if(func_ref == 0) return false;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_pushnumber(lua,a);
lua_pushnumber(lua,b);
lua_pushnumber(lua,c);
lua_pushnumber(lua,d);
if(lua_pcall(lua,5,0,0) != 0)
{
// Error!!
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScriptWith3Args(int func_ref, urAPI_Region_t* region, float a, float b, float c)
{
if(func_ref == 0) return false;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_pushnumber(lua,a);
lua_pushnumber(lua,b);
lua_pushnumber(lua,c);
if(lua_pcall(lua,4,0,0) != 0)
{
// Error!!
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScriptWith2Args(int func_ref, urAPI_Region_t* region, float a, float b)
{
if(func_ref == 0) return false;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_pushnumber(lua,a);
lua_pushnumber(lua,b);
if(lua_pcall(lua,3,0,0) != 0)
{
//<return Error>
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScriptWith1Args(int func_ref, urAPI_Region_t* region, float a)
{
if(func_ref == 0) return false;
// int func_ref = region->OnDragging;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_pushnumber(lua,a);
if(lua_pcall(lua,2,0,0) != 0)
{
//<return Error>
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScriptWith1Global(int func_ref, urAPI_Region_t* region, const char* globaldata)
{
if(func_ref == 0) return false;
// int func_ref = region->OnDragging;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_getglobal(lua, globaldata);
if(lua_pcall(lua,2,0,0) != 0)
{
//<return Error>
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScriptWith1String(int func_ref, urAPI_Region_t* region, const char* name)
{
if(func_ref == 0) return false;
// int func_ref = region->OnDragging;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
lua_pushstring(lua, name);
if(lua_pcall(lua,2,0,0) != 0)
{
//<return Error>
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
bool callScript(int func_ref, urAPI_Region_t* region)
{
if(func_ref == 0) return false;
// Call lua function by stored Reference
lua_rawgeti(lua,LUA_REGISTRYINDEX, func_ref);
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
if(lua_pcall(lua,1,0,0) != 0) // find table of udata here!!
{
//<return Error>
const char* error = lua_tostring(lua, -1);
errorstr = error; // DPrinting errors for now
newerror = true;
return false;
}
// OK!
return true;
}
int region_Handle(lua_State* lua)
{
urAPI_Region_t* region
= checkregion(lua,1);
//get parameter
const char* handler = luaL_checkstring(lua, 2);
if(lua_isnil(lua,3))
{
if(!strcmp(handler, "OnDragStart"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnDragStart);
region->OnDragStart = 0;
}
else if(!strcmp(handler, "OnDragStop"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnDragStop);
region->OnDragStop = 0;
}
else if(!strcmp(handler, "OnEnter"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnEnter);
region->OnEnter = 0;
}
else if(!strcmp(handler, "OnEvent"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnEvent);
region->OnEvent = 0;
}
else if(!strcmp(handler, "OnHide"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnHide);
region->OnHide = 0;
}
else if(!strcmp(handler, "OnLeave"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnLeave);
region->OnLeave = 0;
}
else if(!strcmp(handler, "OnTouchDown"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnTouchDown);
region->OnTouchDown = 0;
}
else if(!strcmp(handler, "OnTouchUp"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnTouchUp);
region->OnTouchUp = 0;
}
else if(!strcmp(handler, "OnShow"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnShow);
region->OnShow = 0;
}
else if(!strcmp(handler, "OnSizeChanged"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnSizeChanged);
region->OnSizeChanged = 0;
}
else if(!strcmp(handler, "OnUpdate"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnUpdate);
region->OnUpdate = 0;
}
else if(!strcmp(handler, "OnDoubleTap"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnDoubleTap);
region->OnDoubleTap = 0;
}
else if(!strcmp(handler, "OnAccelerate"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnAccelerate);
region->OnAccelerate = 0;
}
else if(!strcmp(handler, "OnNetIn"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnNetIn);
region->OnNetIn = 0;
}
else if(!strcmp(handler, "OnNetConnect"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnNetConnect);
region->OnNetConnect = 0;
}
else if(!strcmp(handler, "OnNetDisconnect"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnNetDisconnect);
region->OnNetDisconnect = 0;
}
#ifdef SANDWICH_SUPPORT
else if(!strcmp(handler, "OnPressure"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnPressure);
region->OnPressure = 0;
}
#endif
else if(!strcmp(handler, "OnHeading"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnHeading);
region->OnHeading = 0;
}
else if(!strcmp(handler, "OnLocation"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnLocation);
region->OnLocation = 0;
}
else if(!strcmp(handler, "OnMicrophone"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnMicrophone);
region->OnMicrophone = 0;
}
else if(!strcmp(handler, "OnHorizontalScroll"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnHorizontalScroll);
region->OnHorizontalScroll = 0;
}
else if(!strcmp(handler, "OnVerticalScroll"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnVerticalScroll);
region->OnVerticalScroll = 0;
}
else if(!strcmp(handler, "OnPageEntered"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnPageEntered);
region->OnPageEntered = 0;
}
else if(!strcmp(handler, "OnPageLeft"))
{
luaL_unref(lua, LUA_REGISTRYINDEX, region->OnPageLeft);
region->OnPageLeft = 0;
}
else
luaL_error(lua, "Trying to set a script for an unknown event: %s",handler);
return 0; // Error, unknown event
return 1;
}
else
{
luaL_argcheck(lua, lua_isfunction(lua,3), 3, "'function' expected");
if(lua_isfunction(lua,3))
{
/* char* func = (char*)lua_topointer(lua,3);
// <Also get some other info like function name, argument count>
// Load the function to memory
luaL_loadbuffer(lua,func,strlen(func),"LuaFunction");
lua_pop(lua,1);
*/
// Store funtion reference
lua_pushvalue(lua, 3);
int func_ref = luaL_ref(lua, LUA_REGISTRYINDEX);
// OnDragStart
// OnDragStop
// OnEnter
// OnEvent
// OnHide
// OnLeave
// OnTouchDown
// OnTouchUp
// OnReceiveDrag (NYI)
// OnShow
// OnSizeChanged
// OnUpdate
// OnDoubleTap (UR!)
if(!strcmp(handler, "OnDragStart"))
region->OnDragStart = func_ref;
else if(!strcmp(handler, "OnDragStop"))
region->OnDragStop = func_ref;
else if(!strcmp(handler, "OnEnter"))
region->OnEnter = func_ref;
else if(!strcmp(handler, "OnEvent"))
region->OnEvent = func_ref;
else if(!strcmp(handler, "OnHide"))
region->OnHide = func_ref;
else if(!strcmp(handler, "OnLeave"))
region->OnLeave = func_ref;
else if(!strcmp(handler, "OnTouchDown"))
region->OnTouchDown = func_ref;
else if(!strcmp(handler, "OnTouchUp"))
region->OnTouchUp = func_ref;
else if(!strcmp(handler, "OnShow"))
region->OnShow = func_ref;
else if(!strcmp(handler, "OnSizeChanged"))
region->OnSizeChanged = func_ref;
else if(!strcmp(handler, "OnUpdate"))
region->OnUpdate = func_ref;
else if(!strcmp(handler, "OnDoubleTap"))
region->OnDoubleTap = func_ref;
else if(!strcmp(handler, "OnAccelerate"))
region->OnAccelerate = func_ref;
else if(!strcmp(handler, "OnNetIn"))
region->OnNetIn = func_ref;
else if(!strcmp(handler, "OnNetConnect"))
region->OnNetConnect = func_ref;
else if(!strcmp(handler, "OnNetDisconnect"))
region->OnNetDisconnect = func_ref;
#ifdef SANDWICH_SUPPORT
else if(!strcmp(handler, "OnPressure"))
region->OnPressure = func_ref;
#endif
else if(!strcmp(handler, "OnHeading"))
region->OnHeading = func_ref;
else if(!strcmp(handler, "OnLocation"))
region->OnLocation = func_ref;
else if(!strcmp(handler, "OnMicrophone"))
region->OnMicrophone = func_ref;
else if(!strcmp(handler, "OnHorizontalScroll"))
region->OnHorizontalScroll = func_ref;
else if(!strcmp(handler, "OnVerticalScroll"))
region->OnVerticalScroll = func_ref;
else if(!strcmp(handler, "OnPageEntered"))
region->OnPageEntered = func_ref;
else if(!strcmp(handler, "OnPageLeft"))
region->OnPageLeft = func_ref;
else
luaL_unref(lua, LUA_REGISTRYINDEX, func_ref);
// OK!
return 1;
}
return 0;
}
}
int region_SetHeight(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_Number height = luaL_checknumber(lua,2);
region->height=height;
if(region->textlabel!=NULL)
region->textlabel->updatestring = true;
region->update = true;
if(!layout(region)) // Change may not have had a layouting effect on parent, but still could affect children that are anchored to Y
layoutchildren(region);
return 0;
}
int region_SetWidth(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_Number width = luaL_checknumber(lua,2);
region->width=width;
if(region->textlabel!=NULL)
region->textlabel->updatestring = true;
region->update = true;
if(!layout(region)) // Change may not have had a layouting effect on parent, but still could affect children that are anchored to X
layoutchildren(region);
return 0;
}
int region_EnableInput(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool enableinput = lua_toboolean(lua,2); //!lua_isnil(lua,2);
region->isTouchEnabled = enableinput;
return 0;
}
int region_EnableHorizontalScroll(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool enablescrollx = lua_toboolean(lua,2); //!lua_isnil(lua,2);
region->isScrollXEnabled = enablescrollx;
return 0;
}
int region_EnableVerticalScroll(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool enablescrolly = lua_toboolean(lua,2); //!lua_isnil(lua,2);
region->isScrollYEnabled = enablescrolly;
return 0;
}
int region_EnableClipping(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool enableclipping = lua_toboolean(lua,2); //!lua_isnil(lua,2);
region->isClipping = enableclipping;
return 0;
}
int region_SetClipRegion(lua_State* lua)
{
urAPI_Region_t* t = checkregion(lua, 1);
t->clipleft = luaL_checknumber(lua, 2);
t->clipbottom = luaL_checknumber(lua, 3);
t->clipwidth = luaL_checknumber(lua, 4);
t->clipheight = luaL_checknumber(lua, 5);
return 0;
}
int region_ClipRegion(lua_State* lua)
{
urAPI_Region_t* t = checkregion(lua, 1);
lua_pushnumber(lua, t->clipleft);
lua_pushnumber(lua, t->clipbottom);
lua_pushnumber(lua, t->clipwidth);
lua_pushnumber(lua, t->clipheight);
return 4;
}
int region_EnableMoving(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool setmovable = lua_toboolean(lua,2);//!lua_isnil(lua,2);
region->isMovable = setmovable;
return 0;
}
int region_EnableResizing(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool setresizable = lua_toboolean(lua,2);//!lua_isnil(lua,2);
region->isResizable = setresizable;
return 0;
}
void ClampRegion(urAPI_Region_t* region);
int region_SetAnchor(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
if(region==UIParent) return 0;
lua_Number ofsx;
lua_Number ofsy;
urAPI_Region_t* relativeRegion = UIParent;
const char* point = luaL_checkstring(lua, 2);
const char* relativePoint = DEFAULT_RPOINT;
if(lua_isnil(lua,3)) // SetAnchor(point);
{
}
else
{
if(lua_isnumber(lua, 3) && lua_isnumber(lua, 4)) // SetAnchor(point, x,y);
{
ofsx = luaL_checknumber(lua, 3);
ofsy = luaL_checknumber(lua, 4);
}
else
{
if(lua_isstring(lua, 3)) // SetAnchor(point, "relativeRegion")
{
// find parent here
}
else // SetAnchor(point, relativeRegion)
relativeRegion = checkregion(lua, 3);
if(lua_isstring(lua, 4))
relativePoint = luaL_checkstring(lua, 4);
if(lua_isnumber(lua, 5) && lua_isnumber(lua, 6)) // SetAnchor(point, x,y);
{
ofsx = luaL_checknumber(lua, 5);
ofsy = luaL_checknumber(lua, 6);
}
}
}
if(relativeRegion == region)
{
luaL_error(lua, "Cannot anchor a region to itself.");
return 0;
}
if(region->point != NULL)
free(region->point);
region->point = (char*)malloc(strlen(point)+1);
strcpy(region->point, point);
region->relativeRegion = relativeRegion;
if(relativeRegion != region->parent)
{
removeChild(region->parent, region);
region->parent = relativeRegion;
addChild(relativeRegion, region);
}
if(region->relativePoint != NULL)
free(region->relativePoint);
region->relativePoint = (char*)malloc(strlen(relativePoint)+1);
strcpy(region->relativePoint, relativePoint);
region->ofsx = ofsx;
region->ofsy = ofsy;
region->update = true;
layout(region);
if(region->isClamped)
ClampRegion(region);
return true;
}
int region_Show(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
region->isShown = true;
if(visibleparent(region)) // Check visibility change for children
{
region->isVisible = true;
if(region->OnShow != 0)
callScript(region->OnShow, region);
showchildren(region);
}
return 0;
}
int region_Hide(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
region->isVisible = false;
region->isShown = false;
if(region->OnHide != 0)
callScript(region->OnHide, region);
hidechildren(region); // parent got hidden so hide children too.
return 0;
}
const char STRATASTRING_PARENT[] = "PARENT";
const char STRATASTRING_BACKGROUND[] = "BACKGROUND";
const char STRATASTRING_LOW[] = "LOW";
const char STRATASTRING_MEDIUM[] = "MEDIUM";
const char STRATASTRING_HIGH[] = "HIGH";
const char STRATASTRING_DIALOG[] = "DIALOG";
const char STRATASTRING_FULLSCREEN[] = "FULLSCREEN";
const char STRATASTRING_FULLSCREEN_DIALOG[] = "FULLSCREEN_DIALOG";
const char STRATASTRING_TOOLTIP[] = "TOOLTIP";
const char* region_strataindex2str(int strataidx)
{
switch(strataidx)
{
case STRATA_PARENT:
return STRATASTRING_PARENT;
case STRATA_BACKGROUND:
return STRATASTRING_BACKGROUND;
case STRATA_LOW:
return STRATASTRING_LOW;
case STRATA_MEDIUM:
return STRATASTRING_MEDIUM;
case STRATA_HIGH:
return STRATASTRING_HIGH;
case STRATA_FULLSCREEN:
return STRATASTRING_FULLSCREEN;
case STRATA_FULLSCREEN_DIALOG:
return STRATASTRING_FULLSCREEN_DIALOG;
case STRATA_TOOLTIP:
return STRATASTRING_TOOLTIP;
default:
return nil;
}
}
int region_strata2index(const char* strata)
{
if(!strcmp(strata, "PARENT"))
return STRATA_PARENT;
else if(!strcmp(strata, "BACKGROUND"))
return STRATA_BACKGROUND;
else if(!strcmp(strata, "LOW"))
return STRATA_LOW;
else if(!strcmp(strata, "MEDIUM"))
return STRATA_MEDIUM;
else if(!strcmp(strata, "HIGH"))
return STRATA_HIGH;
else if(!strcmp(strata, "DIALOG"))
return STRATA_DIALOG;
else if(!strcmp(strata, "FULLSCREEN"))
return STRATA_FULLSCREEN;
else if(!strcmp(strata, "FULLSCREEN_DIALOG"))
return STRATA_FULLSCREEN_DIALOG;
else if(!strcmp(strata, "TOOLTIP"))
return STRATA_TOOLTIP;
else
{
return -1; // unknown strata
}
}
const char LAYERSTRING_BACKGROUND[] = "BACKGROUND";
const char LAYERSTRING_BORDER[] = "BORDER";
const char LAYERSTRING_ARTWORK[] = "ARTWORK";
const char LAYERSTRING_OVERLAY[] = "OVERLAY";
const char LAYERSTRING_HIGHLIGHT[] = "HIGHLIGHT";
const char* region_layerindex2str(int layeridx)
{
switch(layeridx)
{
case LAYER_BACKGROUND:
return LAYERSTRING_BACKGROUND;
case LAYER_BORDER:
return LAYERSTRING_BORDER;
case LAYER_ARTWORK:
return LAYERSTRING_ARTWORK;
case LAYER_OVERLAY:
return LAYERSTRING_OVERLAY;
case LAYER_HIGHLIGHT:
return LAYERSTRING_HIGHLIGHT;
default:
return nil;
}
}
int region_layer2index(const char* layer)
{
if(!strcmp(layer, "BACKGROUND"))
return LAYER_BACKGROUND;
else if(!strcmp(layer, "BORDER"))
return LAYER_BORDER;
else if(!strcmp(layer, "ARTWORK"))
return LAYER_ARTWORK;
else if(!strcmp(layer, "OVERLAY"))
return LAYER_OVERLAY;
else if(!strcmp(layer, "HIGHLIGHT"))
return LAYER_HIGHLIGHT;
else
{
return -1; // unknown layer
}
}
const char WRAPSTRING_WORD[] = "WORD";
const char WRAPSTRING_CHAR[] = "CHAR";
const char WRAPSTRING_CLIP[] = "CLIP";
const char* textlabel_wrapindex2str(int wrapidx)
{
switch(wrapidx)
{
case WRAP_WORD:
return WRAPSTRING_WORD;
case WRAP_CHAR:
return WRAPSTRING_CHAR;
case WRAP_CLIP:
return WRAPSTRING_CLIP;
default:
return nil;
}
}
int textlabel_wrap2index(const char* wrap)
{
if(!strcmp(wrap, "WORD"))
return WRAP_WORD;
else if(!strcmp(wrap, "CHAR"))
return WRAP_CHAR;
else if(!strcmp(wrap, "CLIP"))
return WRAP_CLIP;
else
{
return -1; // unknown wrap
}
}
void l_SortStrata(urAPI_Region_t* region, int strata)
{
if(region->prev == nil && firstRegion[currentPage] == region) // first region!
{
firstRegion[currentPage] = region->next; // unlink!
firstRegion[currentPage]->prev = nil;
}
else if(region->next == nil && lastRegion[currentPage] == region) // last region!
{
lastRegion[currentPage] = region->prev; // unlink!
lastRegion[currentPage]->next = nil;
}
else if(region->prev != NULL && region->next !=NULL)
{
region->prev->next = region->next; // unlink!
region->next->prev = region->prev;
}
for(urAPI_Region_t* t=firstRegion[currentPage]; t!=NULL; t=t->next)
{
if(t->strata!=STRATA_PARENT) // ignoring PARENT strata regions.
{
if(t->strata > strata) // insert here!
{
if(t == firstRegion[currentPage])
firstRegion[currentPage] = region;
region->prev = t->prev;
if(t->prev != NULL) // Again, may be the first.
t->prev->next = region;
region->next = t; // Link in
t->prev = region; // fix links
region->strata = strata;
// region->prev->next = region;
return; // Done.
}
}
}
if(region!=lastRegion[currentPage])
{
region->prev = lastRegion[currentPage];
region->next = nil;
lastRegion[currentPage]->next = region;
lastRegion[currentPage] = region;
}
else
{
lastRegion[currentPage] = nil;
}
}
void l_setstrataindex(urAPI_Region_t* region , int strataindex)
{
if(strataindex == STRATA_PARENT)
{
region->strata = strataindex;
urAPI_Region_t* p = region->parent;
int newstrataindex = 1;
do
{
if (p->strata != STRATA_PARENT) newstrataindex = p->strata;
p = p->parent;
}
while(p!=NULL && p->strata == 0);
l_SortStrata(region, newstrataindex);
}
if (strataindex > 0 && strataindex != region->strata)
{
region->strata = strataindex;
l_SortStrata(region, strataindex);
}
}
int region_SetLayer(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
const char* strata = luaL_checkstring(lua,2);
if(strata)
{
int strataindex = region_strata2index(strata);
if( region == firstRegion[currentPage] && region == lastRegion[currentPage])
{
// This is a sole region, no need to stratify
}
else
l_setstrataindex(region , strataindex);
region->strata = strataindex;
}
return 0;
}
int region_Parent(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
if(region != nil)
{
region = region->parent;
lua_rawgeti(lua,LUA_REGISTRYINDEX, region->tableref);
return 1;
}
else
return 0;
}
int region_Children(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
urAPI_Region_t* child = region->firstchild;
int childcount = 0;
while(child!=NULL)
{
childcount++;
lua_rawgeti(lua,LUA_REGISTRYINDEX, child->tableref);
child = child->nextchild;
}
return childcount;
}
int region_Alpha(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->alpha);
return 1;
}
int region_SetAlpha(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_Number alpha = luaL_checknumber(lua,2);
if(alpha > 1.0) alpha = 1.0;
else if(alpha < 0.0) alpha = 0.0;
region->alpha=alpha;
return 0;
}
int region_Name(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushstring(lua, region->name);
return 1;
}
int region_Bottom(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->bottom);
return 1;
}
int region_Center(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->cx);
lua_pushnumber(lua, region->cy);
return 2;
}
int region_Height(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->height);
return 1;
}
int region_Left(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->left);
return 1;
}
int region_Right(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->right);
return 1;
}
int region_Top(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->top);
return 1;
}
int region_Width(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, region->width);
return 1;
}
int region_NumAnchors(lua_State* lua)
{
// urAPI_Region_t* region = checkregion(lua,1);
lua_pushnumber(lua, 1); // NYI always 1 point for now
return 1;
}
int region_Anchor(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushstring(lua, region->point);
if(region->relativeRegion)
{
lua_rawgeti(lua, LUA_REGISTRYINDEX, region->relativeRegion->tableref);
}
else
lua_pushnil(lua);
lua_pushstring(lua, region->relativePoint);
lua_pushnumber(lua, region->ofsx);
lua_pushnumber(lua, region->ofsy);
return 5;
}
int region_IsShown(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushboolean(lua, region->isVisible);
return 1;
}
int region_IsVisible(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool visible = false;
if(region->parent!=NULL)
visible = region->isVisible && region->parent->isVisible;
else
visible = region->isVisible;
lua_pushboolean(lua, visible );
return 1;
}
void setParent(urAPI_Region_t* region, urAPI_Region_t* parent)
{
if(region!= NULL && parent!= NULL && region != parent)
{
region->relativeRegion = parent;
removeChild(region->parent, region);
if(parent == UIParent)
region->parent = UIParent;
else
{
region->parent = parent;
addChild(parent, region);
}
}
}
int region_SetParent(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
urAPI_Region_t* parent = checkregion(lua, 2);
setParent(region, parent);
region->update = true;
layout(region);
return 0;
}
int region_Layer(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
lua_pushstring(lua, region_strataindex2str(region->strata));
return 1;
}
// NEW!!
int region_Lower(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
if(region->prev != nil)
{
urAPI_Region_t* temp = region->prev;
region->prev = temp->prev;
temp->next = region->next;
temp->prev = region;
region->next = temp;
}
return 0;
}
int region_Raise(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
if(region->next != nil)
{
urAPI_Region_t* temp = region->next;
region->next = temp->next;
temp->prev = region->prev;
temp->next = region;
region->prev = temp;
}
return 0;
}
void removeRegion(urAPI_Region_t* region)
{
int currentPage = region->page;
if(firstRegion[currentPage] == region)
firstRegion[currentPage] = region->next;
if(region->prev != NULL)
region->prev->next = region->next;
if(region->next != NULL)
region->next->prev = region->prev;
if(lastRegion[currentPage] == region)
lastRegion[currentPage] = region->prev;
numRegions[currentPage]--;
}
void freeTexture(urAPI_Texture_t* texture)
{
if(texture->backgroundTex!= NULL)
delete texture->backgroundTex;
// free(texture); // GC should take care of this ... maybe
}
void freeTextLabel(urAPI_TextLabel_t* textlabel)
{
if(textlabel->textlabelTex != NULL)
delete textlabel->textlabelTex;
// delete textlabel; // GC should take care of this ... maybe
}
void freeRegion(urAPI_Region_t* region)
{
removeChild(region->parent, region);
removeRegion(region);
if(region->texture != NULL)
freeTexture(region->texture);
if(region->textlabel != NULL)
freeTextLabel(region->textlabel);
delete region;
}
int region_Free(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
freeRegion(region);
}
int l_FreeAllRegions(lua_State* lua)
{
urAPI_Region_t* t=lastRegion[currentPage];
urAPI_Region_t* p;
while(t != nil)
{
t->isVisible = false;
t->isShown = false;
t->isMovable = false;
t->isResizable = false;
t->isTouchEnabled = false;
t->isScrollXEnabled = false;
t->isScrollYEnabled = false;
t->isVisible = false;
t->isShown = false;
t->isDragged = false;
t->isResized = false;
t->isClamped = false;
t->isClipping = false;
p=t->prev;
freeRegion(t);
t = p;
}
return 0;
}
int region_IsToplevel(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool istop = false;
if(region == lastRegion[currentPage])
{
istop = true;
}
lua_pushboolean(lua, istop);
return 1;
}
int region_MoveToTop(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
if(region != lastRegion[currentPage])
{
if(region->prev != nil) // Could be first region!
region->prev->next = region->next; // unlink!
region->next->prev = region->prev;
// and make last
lastRegion[currentPage]->next = region;
region->next = nil;
lastRegion[currentPage] = region;
}
return 0;
}
// ENDNEW!!
void instantiateTexture(urAPI_Region_t* t);
char TEXTURE_SOLID[] = "Solid Texture";
#define GRADIENT_ORIENTATION_VERTICAL 0
#define GRADIENT_ORIENTATION_HORIZONTAL 1
#define GRADIENT_ORIENTATION_DOWNWARD 2
#define GRADIENT_ORIENTATION_UPWARD 3
int region_Texture(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
const char* texturename;
const char* texturelayer;
int texturelayerindex=1;
float r,g,b,a;
r = 255;
g = 255;
b = 255;
a = 255;
if(lua_gettop(lua)<2 || lua_isnil(lua,2)) // this can legitimately be nil.
texturename = nil;
else
{
if(lua_isstring(lua,2) && lua_gettop(lua) <4)
{
texturename = luaL_checkstring(lua,2);
if(lua_gettop(lua)==3 && !lua_isnil(lua,3)) // this should be set.
{
texturelayer = luaL_checkstring(lua,3);
texturelayerindex = region_layer2index(texturelayer);
}
// NYI arg3.. are inheritsFrom regions
}
else if(lua_isnumber(lua,2)) {
texturename = nil;
r = luaL_checknumber(lua, 2);
if(lua_gettop(lua)>2)
{
g = luaL_checknumber(lua,3);
if(lua_gettop(lua)>3)
{
b = luaL_checknumber(lua,4);
a = 255;
if(lua_gettop(lua)>4)
a = luaL_checknumber(lua,5);
}
else
{
g = r;
b = r;
a = g;
}
}
else {
g = r;
b = r;
a = 255;
}
}
}
urAPI_Texture_t* mytexture = (urAPI_Texture_t*)lua_newuserdata(lua, sizeof(urAPI_Texture_t));
mytexture->blendmode = BLEND_DISABLED;
mytexture->texcoords[0] = 0.0;
mytexture->texcoords[1] = 1.0;
mytexture->texcoords[2] = 1.0;
mytexture->texcoords[3] = 1.0;
mytexture->texcoords[4] = 0.0;
mytexture->texcoords[5] = 0.0;
mytexture->texcoords[6] = 1.0;
mytexture->texcoords[7] = 0.0;
if(texturename == NULL)
mytexture->texturepath = TEXTURE_SOLID;
else
{
mytexture->texturepath = (char*)malloc(strlen(texturename)+1);
strcpy(mytexture->texturepath, texturename);
// mytexture->texturepath = texturename;
}
mytexture->modifyRect = false;
mytexture->isDesaturated = false;
mytexture->isTiled = true;
mytexture->fill = false;
// mytexture->gradientOrientation = GRADIENT_ORIENTATION_VERTICAL; OBSOLETE
mytexture->gradientUL[0] = 255; // R
mytexture->gradientUL[1] = 255; // G
mytexture->gradientUL[2] = 255; // B
mytexture->gradientUL[3] = 255; // A
mytexture->gradientUR[0] = 255; // R
mytexture->gradientUR[1] = 255; // G
mytexture->gradientUR[2] = 255; // B
mytexture->gradientUR[3] = 255; // A
mytexture->gradientBL[0] = 255; // R
mytexture->gradientBL[1] = 255; // G
mytexture->gradientBL[2] = 255; // B
mytexture->gradientBL[3] = 255; // A
mytexture->gradientBR[0] = 255; // R
mytexture->gradientBR[1] = 255; // G
mytexture->gradientBR[2] = 255; // B
mytexture->gradientBR[3] = 255; // A
mytexture->texturesolidcolor[0] = r; // R for solid
mytexture->texturesolidcolor[1] = g; // G
mytexture->texturesolidcolor[2] = b; // B
mytexture->texturesolidcolor[3] = a; // A
mytexture->backgroundTex = NULL;
region->texture = mytexture; // HACK
mytexture->region = region;
luaL_getmetatable(lua, "URAPI.texture");
lua_setmetatable(lua, -2);
if(mytexture->backgroundTex == nil && mytexture->texturepath != TEXTURE_SOLID)
{
instantiateTexture(mytexture->region);
}
return 1;
}
char textlabel_empty[] = "";
const char textlabel_defaultfont[] = "Helvetica";
int region_TextLabel(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
const char* texturename;
const char* texturelayer;
int texturelayerindex=1;
if(lua_gettop(lua)<2 || lua_isnil(lua,2)) // this can legitimately be nil.
texturename = nil;
else
if(!lua_isnil(lua,3)) // this should be set.
{
texturelayer = luaL_checkstring(lua,3);
texturelayerindex = region_layer2index(texturelayer);
}
// NYI arg3.. are inheritsFrom regions
urAPI_TextLabel_t* mytextlabel = (urAPI_TextLabel_t*)lua_newuserdata(lua, sizeof(urAPI_TextLabel_t));
region->textlabel = mytextlabel; // HACK
mytextlabel->text = textlabel_empty;
mytextlabel->updatestring = true;
mytextlabel->font = textlabel_defaultfont;
mytextlabel->justifyh = JUSTIFYH_CENTER;
mytextlabel->justifyv = JUSTIFYV_MIDDLE;
mytextlabel->shadowcolor[0] = 0.0;
mytextlabel->shadowcolor[1] = 0.0;
mytextlabel->shadowcolor[2] = 0.0;
mytextlabel->shadowcolor[3] = 128.0;
mytextlabel->shadowoffset[0] = 0.0;
mytextlabel->shadowoffset[1] = 0.0;
mytextlabel->shadowblur = 0.0;
mytextlabel->drawshadow = false;
mytextlabel->linespacing = 2;
mytextlabel->textcolor[0] = 255.0;
mytextlabel->textcolor[1] = 255.0;
mytextlabel->textcolor[2] = 255.0;
mytextlabel->textcolor[3] = 255.0;
mytextlabel->textheight = 12;
mytextlabel->wrap = WRAP_WORD;
mytextlabel->rotation = 0.0;
mytextlabel->textlabelTex = nil;
luaL_getmetatable(lua, "URAPI.textlabel");
lua_setmetatable(lua, -2);
return 1;
}
#include <vector>
#include <string>
static std::vector<std::string> ur_log;
void ur_Log(const char * str) {
ur_log.push_back(str);
}
extern "C" {
char * ur_GetLog(int since, int *nlog);
}
char * ur_GetLog(int since, int *nlog) {
if(since<0) since=0;
std::string str="";
for(int i=since;i<ur_log.size();i++) {
str+=ur_log[i];
str+="\n";
}
char *result=(char *)malloc(str.length()+1);
strcpy(result, str.c_str());
*nlog=ur_log.size();
return result;
}
int l_DPrint(lua_State* lua)
{
const char* str = luaL_checkstring(lua,1);
if(str!=nil)
{
ur_Log(str);
errorstr = str;
newerror = true;
}
return 0;
}
int l_InputFocus(lua_State* lua)
{
// NYI
return 0;
}
int l_HasInput(lua_State* lua)
{
urAPI_Region_t* t = checkregion(lua, 1);
bool isover = false;
float x,y;
// NYI
if(x >= t->left && x <= t->left+t->width &&
y >= t->bottom && y <= t->bottom+t->height /*&& t->isTouchEnabled*/)
isover = true;
lua_pushboolean(lua, isover);
return 1;
}
extern int SCREEN_WIDTH;
extern int SCREEN_HEIGHT;
int l_ScreenHeight(lua_State* lua)
{
lua_pushnumber(lua, SCREEN_HEIGHT);
return 1;
}
int l_ScreenWidth(lua_State* lua)
{
lua_pushnumber(lua, SCREEN_WIDTH);
return 1;
}
extern float cursorpositionx[MAX_FINGERS];
extern float cursorpositiony[MAX_FINGERS];
// UR: New arg "finger" allows to specify which finger to get position for. nil defaults to 0.
int l_InputPosition(lua_State* lua)
{
int finger = 0;
if(lua_gettop(lua) > 0 && !lua_isnil(lua, 1))
finger = luaL_checknumber(lua, 1);
lua_pushnumber(lua, cursorpositionx[finger]);
lua_pushnumber(lua, SCREEN_HEIGHT-cursorpositiony[finger]);
return 2;
}
int l_Time(lua_State* lua)
{
#ifdef TARGET_IPHONE
lua_pushnumber(lua, [systimer elapsedSec]);
#else
lua_pushnumber(lua, systimer->elapsedSec());
#endif
return 1;
}
int l_RunScript(lua_State* lua)
{
const char* script = luaL_checkstring(lua,1);
if(script != NULL)
luaL_dostring(lua,script);
return 0;
}
int l_StartHTTPServer(lua_State *lua)
{
#ifdef TARGET_IPHONE
NSString *resourcePath = [[NSBundle mainBundle] resourcePath];
NSArray *paths;
paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentPath;
if ([paths count] > 0)
documentPath = [paths objectAtIndex:0];
// start off http server
http_start([resourcePath UTF8String],
[documentPath UTF8String]);
#else
// TODO : use internal storage path
#endif
return 0;
}
int l_StopHTTPServer(lua_State *lua)
{
http_stop();
return 0;
}
int l_HTTPServer(lua_State *lua)
{
const char *ip = http_ip_address();
if (ip) {
lua_pushstring(lua, ip);
lua_pushstring(lua, http_ip_port());
return 2;
} else {
return 0;
}
}
static int audio_initialized = false;
int l_StartAudio(lua_State* lua)
{
#ifdef TARGET_IPHONE
if(!audio_initialized)
{
initializeRIOAudioLayer();
}
else
playRIOAudioLayer();
#else
//TODO// audio stuff
#endif
return 0;
}
int l_PauseAudio(lua_State* lua)
{
#ifdef TARGET_IPHONE
stopRIOAudioLayer();
#else
//TODO// audio stuff
#endif
return 0;
}
static int l_setanimspeed(lua_State *lua)
{
double ds = luaL_checknumber(lua, 1);
#ifdef TARGET_IPHONE
g_glView.animationInterval = ds;
#endif
return 0;
}
int texture_SetTexture(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
if(lua_isnumber(lua,2) && lua_isnumber(lua,3) && lua_isnumber(lua,4))
{
t->texturepath = TEXTURE_SOLID;
t->texturesolidcolor[0] = luaL_checknumber(lua, 2);
t->texturesolidcolor[1] = luaL_checknumber(lua, 3);
t->texturesolidcolor[2] = luaL_checknumber(lua, 4);
if(lua_isnumber(lua, 5))
t->texturesolidcolor[3] = luaL_checknumber(lua, 5);
else
t->texturesolidcolor[3] = 255;
}
else
{
const char* texturename = luaL_checkstring(lua,2);
if(t->texturepath != TEXTURE_SOLID && t->texturepath != NULL)
free(t->texturepath);
t->texturepath = (char*)malloc(strlen(texturename)+1);
strcpy(t->texturepath, texturename);
if(t->backgroundTex != NULL) delete t->backgroundTex; // Antileak
t->backgroundTex = nil;
instantiateTexture(t->region);
}
return 0;
}
int texture_SetGradientColor(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
const char* orientation = luaL_checkstring(lua, 2);
float minR = luaL_checknumber(lua, 3);
float minG = luaL_checknumber(lua, 4);
float minB = luaL_checknumber(lua, 5);
float minA = luaL_checknumber(lua, 6);
float maxR = luaL_checknumber(lua, 7);
float maxG = luaL_checknumber(lua, 8);
float maxB = luaL_checknumber(lua, 9);
float maxA = luaL_checknumber(lua, 10);
if(!strcmp(orientation, "HORIZONTAL"))
{
t->gradientUL[0] = minR;
t->gradientUL[1] = minG;
t->gradientUL[2] = minB;
t->gradientUL[3] = minA;
t->gradientBL[0] = minR;
t->gradientBL[1] = minG;
t->gradientBL[2] = minB;
t->gradientBL[3] = minA;
t->gradientUR[0] = maxR;
t->gradientUR[1] = maxG;
t->gradientUR[2] = maxB;
t->gradientUR[3] = maxA;
t->gradientBR[0] = maxR;
t->gradientBR[1] = maxG;
t->gradientBR[2] = maxB;
t->gradientBR[3] = maxA;
}
else if(!strcmp(orientation, "VERTICAL"))
{
t->gradientUL[0] = minR;
t->gradientUL[1] = minG;
t->gradientUL[2] = minB;
t->gradientUL[3] = minA;
t->gradientUR[0] = minR;
t->gradientUR[1] = minG;
t->gradientUR[2] = minB;
t->gradientUR[3] = minA;
t->gradientBL[0] = maxR;
t->gradientBL[1] = maxG;
t->gradientBL[2] = maxB;
t->gradientBL[3] = maxA;
t->gradientBR[0] = maxR;
t->gradientBR[1] = maxG;
t->gradientBR[2] = maxB;
t->gradientBR[3] = maxA;
}
else if(!strcmp(orientation, "TOP")) // UR! Allows to set the full gradient in 2 calls.
{
t->gradientUL[0] = minR;
t->gradientUL[1] = minG;
t->gradientUL[2] = minB;
t->gradientUL[3] = minA;
t->gradientUR[0] = maxR;
t->gradientUR[1] = maxG;
t->gradientUR[2] = maxB;
t->gradientUR[3] = maxA;
}
else if(!strcmp(orientation, "BOTTOM")) // UR!
{
t->gradientBL[0] = minR;
t->gradientBL[1] = minG;
t->gradientBL[2] = minB;
t->gradientBL[3] = minA;
t->gradientBR[0] = maxR;
t->gradientBR[1] = maxG;
t->gradientBR[2] = maxB;
t->gradientBR[3] = maxA;
}
return 0;
}
int texture_Texture(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
// NYI still don't know how to return user values
return 0;
}
int texture_SetSolidColor(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float vertR = luaL_checknumber(lua, 2);
float vertG = luaL_checknumber(lua, 3);
float vertB = luaL_checknumber(lua, 4);
float vertA = 255;
if(lua_gettop(lua)==5)
vertA = luaL_checknumber(lua, 5);
t->texturesolidcolor[0] = vertR;
t->texturesolidcolor[1] = vertG;
t->texturesolidcolor[2] = vertB;
t->texturesolidcolor[3] = vertA;
return 0;
}
int texture_SolidColor(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
lua_pushnumber(lua, t->texturesolidcolor[0]);
lua_pushnumber(lua, t->texturesolidcolor[1]);
lua_pushnumber(lua, t->texturesolidcolor[2]);
lua_pushnumber(lua, t->texturesolidcolor[3]);
return 4;
}
int texture_SetTexCoord(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
if(lua_gettop(lua)==5)
{
float left = luaL_checknumber(lua, 2);
float right = luaL_checknumber(lua, 3);
float top = luaL_checknumber(lua, 4);
float bottom = luaL_checknumber(lua, 5);
t->texcoords[0] = left; //ULx
t->texcoords[1] = top; // ULy
t->texcoords[2] = right; // URx
t->texcoords[3] = top; // URy
t->texcoords[4] = left; // BLx
t->texcoords[5] = bottom; // BLy
t->texcoords[6] = right; // BRx
t->texcoords[7] = bottom; // BRy
}
else if(lua_gettop(lua)==9)
{
t->texcoords[0] = luaL_checknumber(lua, 2);
t->texcoords[1] = luaL_checknumber(lua, 3);
t->texcoords[2] = luaL_checknumber(lua, 4);
t->texcoords[3] = luaL_checknumber(lua, 5);
t->texcoords[4] = luaL_checknumber(lua, 6);
t->texcoords[5] = luaL_checknumber(lua, 7);
t->texcoords[6] = luaL_checknumber(lua, 8);
t->texcoords[7] = luaL_checknumber(lua, 9);
}
return 0;
}
int texture_TexCoord(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
lua_pushnumber(lua, t->texcoords[0]);
lua_pushnumber(lua, t->texcoords[1]);
lua_pushnumber(lua, t->texcoords[2]);
lua_pushnumber(lua, t->texcoords[3]);
lua_pushnumber(lua, t->texcoords[4]);
lua_pushnumber(lua, t->texcoords[5]);
lua_pushnumber(lua, t->texcoords[6]);
lua_pushnumber(lua, t->texcoords[7]);
return 8;
}
int texture_SetRotation(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float angle = luaL_checknumber(lua, 2);
float s = sqrt(2.0)/2.0*sin(angle);
float c = sqrt(2.0)/2.0*cos(angle);
// x = r*math.sin(angle+math.pi/4)
// y = r*math.cos(angle+math.pi/4)
// hand.t:SetTexCoord(.5-x,.5+y, .5+y,.5+x, .5-y,.5-x, .5+x,.5-y)
// r = math.sqrt(2)/2
t->texcoords[0] = 0.5-s;
t->texcoords[1] = 0.5+c;
t->texcoords[2] = 0.5+c;
t->texcoords[3] = 0.5+s;
t->texcoords[4] = 0.5-c;
t->texcoords[5] = 0.5-s;
t->texcoords[6] = 0.5+s;
t->texcoords[7] = 0.5-c;
return 0;
}
int texture_SetTiling(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
t->isTiled = lua_toboolean(lua,2);
return 0;
}
int region_EnableClamping(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
bool clamped = lua_toboolean(lua,2); //!lua_isnil(lua,2);
region->isClamped = clamped;
return 0;
}
int region_RegionOverlap(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
urAPI_Region_t* region2 = checkregion(lua,2);
if( region->left < region2->right &&
region2->left < region->right &&
region->bottom < region2->top &&
region2->bottom < region->top)
{
lua_pushboolean(lua, true);
return 1;
}
return 0;
}
int texture_SetTexCoordModifiesRect(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
bool modifyrect = lua_toboolean(lua,2); //!lua_isnil(lua,2);
t->modifyRect = modifyrect;
return 0;
}
int texture_TexCoordModifiesRect(lua_State* lua)
{
urAPI_Texture_t* t= checktexture(lua, 1);
lua_pushboolean(lua, t->modifyRect);
return 1;
}
int texture_SetDesaturated(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
bool isDesaturated = lua_toboolean(lua,2); //!lua_isnil(lua,2);
t->isDesaturated = isDesaturated;
return 0;
}
int texture_IsDesaturated(lua_State* lua)
{
urAPI_Texture_t* t= checktexture(lua, 1);
lua_pushboolean(lua, t->isDesaturated);
return 1;
}
const char BLENDSTR_DISABLED[] = "DISABLED";
const char BLENDSTR_BLEND[] = "BLEND";
const char BLENDSTR_ALPHAKEY[] = "ALPHAKEY";
const char BLENDSTR_ADD[] = "ADD";
const char BLENDSTR_MOD[] = "MOD";
const char BLENDSTR_SUB[] = "SUB";
int texture_SetBlendMode(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
const char* blendmode = luaL_checkstring(lua, 2);
if(!strcmp(blendmode, BLENDSTR_DISABLED))
t->blendmode = BLEND_DISABLED;
else if(!strcmp(blendmode, BLENDSTR_BLEND))
t->blendmode = BLEND_BLEND;
else if(!strcmp(blendmode, BLENDSTR_ALPHAKEY))
t->blendmode = BLEND_ALPHAKEY;
else if(!strcmp(blendmode, BLENDSTR_ADD))
t->blendmode = BLEND_ADD;
else if(!strcmp(blendmode, BLENDSTR_MOD))
t->blendmode = BLEND_MOD;
else if(!strcmp(blendmode, BLENDSTR_SUB))
t->blendmode = BLEND_SUB;
else
{
// NYI unknown blend
}
return 0;
}
int texture_BlendMode(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
const char* returnstr;
switch(t->blendmode)
{
case BLEND_DISABLED:
returnstr = BLENDSTR_DISABLED;
break;
case BLEND_BLEND:
returnstr = BLENDSTR_BLEND;
break;
case BLEND_ALPHAKEY:
returnstr = BLENDSTR_ALPHAKEY;
break;
case BLEND_ADD:
returnstr = BLENDSTR_ADD;
break;
case BLEND_MOD:
returnstr = BLENDSTR_MOD;
break;
case BLEND_SUB:
returnstr = BLENDSTR_SUB;
break;
default:
luaL_error(lua, "Bogus blend mode found! Please report.");
return 0; // Error, unknown event
// returnstr = BLENDSTR_DISABLED; // This should never happen!! Error case NYI
break;
}
lua_pushstring(lua, returnstr);
return 1;
}
void drawLineToTexture(urAPI_Texture_t *texture, float startx, float starty, float endx, float endy);
int texture_Line(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float startx = luaL_checknumber(lua, 2);
float starty = luaL_checknumber(lua, 3);
float endx = luaL_checknumber(lua, 4);
float endy = luaL_checknumber(lua, 5);
if(t->backgroundTex != nil)
drawLineToTexture(t, startx, starty, endx, endy);
return 0;
}
void drawEllipseToTexture(urAPI_Texture_t *texture, float x, float y, float w, float h);
int texture_Ellipse(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float x = luaL_checknumber(lua, 2);
float y = luaL_checknumber(lua, 3);
float w = luaL_checknumber(lua, 4);
float h = luaL_checknumber(lua, 5);
if(t->backgroundTex != nil)
drawEllipseToTexture(t, x, y, w, h);
return 0;
}
void drawQuadToTexture(urAPI_Texture_t *texture, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
int texture_Quad(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float x1 = luaL_checknumber(lua, 2);
float y1 = luaL_checknumber(lua, 3);
float x2 = luaL_checknumber(lua, 4);
float y2 = luaL_checknumber(lua, 5);
float x3 = luaL_checknumber(lua, 6);
float y3 = luaL_checknumber(lua, 7);
float x4 = luaL_checknumber(lua, 8);
float y4 = luaL_checknumber(lua, 9);
if(t->backgroundTex != nil)
drawQuadToTexture(t, x1, y1, x2, y2, x3, y3, x4, y4);
return 0;
}
int texture_Rect(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float x = luaL_checknumber(lua, 2);
float y = luaL_checknumber(lua, 3);
float w = luaL_checknumber(lua, 4);
float h = luaL_checknumber(lua, 5);
if(t->backgroundTex != nil)
drawQuadToTexture(t, x, y, x+w, y, x+w, y+h, x, y+h);
return 0;
}
int texture_SetFill(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
bool fill = lua_toboolean(lua,2); //!lua_isnil(lua,2);
t->fill = fill;
return 0;
}
void clearTexture(urTexture* t, float r, float g, float b, float a);
int texture_Clear(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float r = 0.0;
float g = 0.0;
float b = 0.0;
float a = 1.0;
if(lua_gettop(lua)>3)
{
r = luaL_checknumber(lua, 2)/255.0;
g = luaL_checknumber(lua, 3)/255.0;
b = luaL_checknumber(lua, 4)/255.0;
}
if(lua_gettop(lua)==5)
{
a = luaL_checknumber(lua, 5)/255.0;
}
if(t->backgroundTex == nil && t->texturepath != TEXTURE_SOLID)
instantiateTexture(t->region);
if(t->backgroundTex != nil)
clearTexture(t->backgroundTex,r,g,b,a);
return 0;
}
int texture_Width(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
lua_pushnumber(lua, t->width);
return 1;
}
int texture_Height(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
lua_pushnumber(lua, t->height);
return 1;
}
void ClearBrushTexture();
int texture_ClearBrush(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
delete t->backgroundTex;
t->backgroundTex = nil;
ClearBrushTexture();
}
void drawPointToTexture(urAPI_Texture_t *texture, float x, float y);
int texture_Point(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float x = luaL_checknumber(lua, 2);
float y = luaL_checknumber(lua, 3);
if(t->backgroundTex != nil)
drawPointToTexture(t, x, y);
return 0;
}
void SetBrushSize(float size);
int texture_SetBrushSize(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float size = luaL_checknumber(lua, 2);
SetBrushSize(size);
return 0;
}
int texture_SetBrushColor(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float vertR = luaL_checknumber(lua, 2);
float vertG = luaL_checknumber(lua, 3);
float vertB = luaL_checknumber(lua, 4);
float vertA = 255;
if(lua_gettop(lua)==5)
vertA = luaL_checknumber(lua, 5);
t->texturebrushcolor[0] = vertR;
t->texturebrushcolor[1] = vertG;
t->texturebrushcolor[2] = vertB;
t->texturebrushcolor[3] = vertA;
return 0;
}
float BrushSize();
int texture_BrushSize(lua_State* lua)
{
urAPI_Texture_t* t = checktexture(lua, 1);
float size = BrushSize();
lua_pushnumber(lua, size);
return 1;
}
void SetBrushTexture(urTexture* t);
int region_UseAsBrush(lua_State* lua)
{
urAPI_Region_t* t = checkregion(lua, 1);
if(t->texture->backgroundTex == nil && t->texture->texturepath != TEXTURE_SOLID)
instantiateTexture(t);
SetBrushTexture(t->texture->backgroundTex);
return 0;
}
int textlabel_Font(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushstring(lua, t->font);
return 1;
}
int textlabel_SetFont(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->font = luaL_checkstring(lua,2); // NYI
return 0;
}
const char JUSTIFYH_STRING_CENTER[] = "CENTER";
const char JUSTIFYH_STRING_LEFT[] = "LEFT";
const char JUSTIFYH_STRING_RIGHT[] = "RIGHT";
const char JUSTIFYV_STRING_MIDDLE[] = "MIDDLE";
const char JUSTIFYV_STRING_TOP[] = "TOP";
const char JUSTIFYV_STRING_BOTTOM[] = "BOTTOM";
int textlabel_HorizontalAlign(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* justifyh;
switch(t->justifyh)
{
case JUSTIFYH_CENTER:
justifyh = JUSTIFYH_STRING_CENTER;
break;
case JUSTIFYH_LEFT:
justifyh = JUSTIFYH_STRING_LEFT;
break;
case JUSTIFYH_RIGHT:
justifyh = JUSTIFYH_STRING_RIGHT;
break;
}
lua_pushstring(lua, justifyh);
return 1;
}
int textlabel_SetHorizontalAlign(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* justifyh = luaL_checkstring(lua, 2);
if(!strcmp(justifyh, JUSTIFYH_STRING_CENTER))
t->justifyh = JUSTIFYH_CENTER;
else if(!strcmp(justifyh, JUSTIFYH_STRING_LEFT))
t->justifyh = JUSTIFYH_LEFT;
else if(!strcmp(justifyh, JUSTIFYH_STRING_RIGHT))
t->justifyh = JUSTIFYH_RIGHT;
return 0;
}
int textlabel_VerticalAlign(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* justifyv;
switch(t->justifyv)
{
case JUSTIFYV_MIDDLE:
justifyv = JUSTIFYV_STRING_MIDDLE;
break;
case JUSTIFYV_TOP:
justifyv = JUSTIFYV_STRING_TOP;
break;
case JUSTIFYV_BOTTOM:
justifyv = JUSTIFYV_STRING_BOTTOM;
break;
}
lua_pushstring(lua, justifyv);
return 1;
}
int textlabel_SetVerticalAlign(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* justifyv = luaL_checkstring(lua, 2);
if(!strcmp(justifyv, JUSTIFYV_STRING_MIDDLE))
t->justifyv = JUSTIFYV_MIDDLE;
else if(!strcmp(justifyv, JUSTIFYV_STRING_TOP))
t->justifyv = JUSTIFYV_TOP;
else if(!strcmp(justifyv, JUSTIFYV_STRING_BOTTOM))
t->justifyv = JUSTIFYV_BOTTOM;
return 0;
}
int textlabel_SetWrap(lua_State* lua)
{
urAPI_TextLabel_t* textlabel = checktextlabel(lua,1);
const char* wrap = luaL_checkstring(lua,2);
if(wrap)
{
textlabel->wrap = textlabel_wrap2index(wrap);
}
return 0;
}
int textlabel_Wrap(lua_State* lua)
{
urAPI_TextLabel_t* textlabel = checktextlabel(lua,1);
lua_pushstring(lua, textlabel_wrapindex2str(textlabel->wrap));
return 1;
}
int textlabel_ShadowColor(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->shadowcolor[0]);
lua_pushnumber(lua, t->shadowcolor[1]);
lua_pushnumber(lua, t->shadowcolor[2]);
lua_pushnumber(lua, t->shadowcolor[3]);
return 4;
}
int textlabel_SetShadowColor(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->shadowcolor[0] = luaL_checknumber(lua,2);
t->shadowcolor[1] = luaL_checknumber(lua,3);
t->shadowcolor[2] = luaL_checknumber(lua,4);
t->shadowcolor[3] = luaL_checknumber(lua,5);
t->drawshadow = true;
t->updatestring = true;
return 0;
}
int textlabel_ShadowOffset(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->shadowoffset[0]);
lua_pushnumber(lua, t->shadowoffset[1]);
return 2;
}
int textlabel_SetShadowOffset(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->shadowoffset[0] = luaL_checknumber(lua,2);
t->shadowoffset[1] = luaL_checknumber(lua,3);
t->updatestring = true;
return 0;
}
int textlabel_ShadowBlur(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->shadowblur);
return 1;
}
int textlabel_SetShadowBlur(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->shadowblur = luaL_checknumber(lua,2);
t->updatestring = true;
return 0;
}
int textlabel_Spacing(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->linespacing);
return 1;
}
int textlabel_SetSpacing(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->linespacing = luaL_checknumber(lua,2);
return 0;
}
int textlabel_Color(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->textcolor[0]);
lua_pushnumber(lua, t->textcolor[1]);
lua_pushnumber(lua, t->textcolor[2]);
lua_pushnumber(lua, t->textcolor[3]);
return 4;
}
int textlabel_SetColor(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->textcolor[0] = luaL_checknumber(lua,2);
t->textcolor[1] = luaL_checknumber(lua,3);
t->textcolor[2] = luaL_checknumber(lua,4);
t->textcolor[3] = luaL_checknumber(lua,5);
return 0;
}
int textlabel_Height(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->stringheight); // NYI
return 1;
}
int textlabel_Width(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushnumber(lua, t->stringwidth); // NYI
return 1;
}
int textlabel_SetLabelHeight(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->textheight = luaL_checknumber(lua,2);
return 0;
}
int textlabel_Label(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
lua_pushstring(lua, t->text);
return 1;
}
int textlabel_SetLabel(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* text = luaL_checkstring(lua,2);
if(t->text != NULL && t->text != textlabel_empty)
free(t->text);
t->text = (char*)malloc(strlen(text)+1);
strcpy(t->text, text);
t->updatestring = true;
return 0;
}
int textlabel_SetFormattedText(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
const char* text = luaL_checkstring(lua,2);
if(t->text != NULL && t->text != textlabel_empty)
free(t->text);
t->text = (char*)malloc(strlen(text)+1);
strcpy(t->text, text);
// NYI
return 0;
}
int textlabel_SetRotation(lua_State* lua)
{
urAPI_TextLabel_t* t = checktextlabel(lua, 1);
t->rotation = luaL_checknumber(lua,2);
return 0;
}
static const struct luaL_reg textlabelfuncs [] =
{
{"Font", textlabel_Font},
{"HorizontalAlign", textlabel_HorizontalAlign},
{"VerticalAlign", textlabel_VerticalAlign},
{"ShadowColor", textlabel_ShadowColor},
{"ShadowOffset", textlabel_ShadowOffset},
{"ShadowBlur", textlabel_ShadowBlur},
{"Spacing", textlabel_Spacing},
{"Color", textlabel_Color},
{"SetFont", textlabel_SetFont},
{"SetHorizontalAlign", textlabel_SetHorizontalAlign},
{"SetVerticalAlign", textlabel_SetVerticalAlign},
{"SetShadowColor", textlabel_SetShadowColor},
{"SetShadowOffset", textlabel_SetShadowOffset},
{"SetShadowBlur", textlabel_SetShadowBlur},
{"SetSpacing", textlabel_SetSpacing},
{"SetColor", textlabel_SetColor},
{"Height", textlabel_Height},
{"Width", textlabel_Width},
{"Label", textlabel_Label},
{"SetFormattedText", textlabel_SetFormattedText},
{"SetWrap", textlabel_SetWrap},
{"Wrap", textlabel_Wrap},
{"SetLabel", textlabel_SetLabel},
{"SetLabelHeight", textlabel_SetLabelHeight},
{"SetRotation", textlabel_SetRotation},
{NULL, NULL}
};
int texture_gc(lua_State* lua)
{
urAPI_Texture_t* region = checktexture(lua,1);
int a = 0;
return 0;
}
static const struct luaL_reg texturefuncs [] =
{
{"SetTexture", texture_SetTexture},
// {"SetGradient", texture_SetGradient},
{"SetGradientColor", texture_SetGradientColor},
{"Texture", texture_Texture},
{"SetSolidColor", texture_SetSolidColor},
{"SolidColor", texture_SolidColor},
{"SetTexCoord", texture_SetTexCoord},
{"TexCoord", texture_TexCoord},
{"SetRotation", texture_SetRotation},
{"SetTexCoordModifiesRect", texture_SetTexCoordModifiesRect},
{"TexCoordModifiesRect", texture_TexCoordModifiesRect},
{"SetDesaturated", texture_SetDesaturated},
{"IsDesaturated", texture_IsDesaturated},
{"SetBlendMode", texture_SetBlendMode},
{"BlendMode", texture_BlendMode},
{"Line", texture_Line},
{"Point", texture_Point},
{"Ellipse", texture_Ellipse},
{"Quad", texture_Quad},
{"Rect", texture_Rect},
{"Clear", texture_Clear},
{"ClearBrush", texture_ClearBrush},
{"SetFill", texture_SetFill},
{"SetBrushSize", texture_SetBrushSize},
{"BrushSize", texture_BrushSize},
{"SetBrushColor", texture_SetBrushColor},
{"SetTiling", texture_SetTiling},
{"Width", texture_Width},
{"Height", texture_Height},
// {"__gc", texture_gc},
{NULL, NULL}
};
int region_gc(lua_State* lua)
{
urAPI_Region_t* region = checkregion(lua,1);
int a = 0;
return 0;
}
static const struct luaL_reg regionfuncs [] =
{
{"EnableMoving", region_EnableMoving},
{"EnableResizing", region_EnableResizing},
{"Handle", region_Handle},
{"SetHeight", region_SetHeight},
{"SetWidth", region_SetWidth},
{"Show", region_Show},
{"Hide", region_Hide},
{"EnableInput", region_EnableInput},
{"EnableHorizontalScroll", region_EnableHorizontalScroll},
{"EnableVerticalScroll", region_EnableVerticalScroll},
{"SetAnchor", region_SetAnchor},
{"SetLayer", region_SetLayer},
{"Parent", region_Parent},
{"Children", region_Children},
{"Name", region_Name},
{"Bottom", region_Bottom},
{"Center", region_Center},
{"Height", region_Height},
{"Left", region_Left},
{"NumAnchors", region_NumAnchors},
{"Anchor", region_Anchor},
{"Right", region_Right},
{"Top", region_Top},
{"Width", region_Width},
{"IsShown", region_IsShown},
{"IsVisible", region_IsVisible},
{"SetParent", region_SetParent},
{"SetAlpha", region_SetAlpha},
{"Alpha", region_Alpha},
{"Layer", region_Layer},
{"Texture", region_Texture},
{"TextLabel", region_TextLabel},
// NEW!!
{"Lower", region_Lower},
{"Raise", region_Raise},
{"IsToplevel", region_IsToplevel},
{"MoveToTop", region_MoveToTop},
{"EnableClamping", region_EnableClamping},
// ENDNEW!!
{"RegionOverlap", region_RegionOverlap},
{"UseAsBrush", region_UseAsBrush},
{"EnableClipping", region_EnableClipping},
{"SetClipRegion", region_SetClipRegion},
{"ClipRegion", region_ClipRegion},
{"__gc", region_gc},
{NULL, NULL}
};
static const luaL_reg regionmetas[] = {
{"__gc", region_gc},
{0, 0}
};
void addChild(urAPI_Region_t *parent, urAPI_Region_t *child)
{
if(parent->firstchild == NULL)
parent->firstchild = child;
else
{
urAPI_Region_t *findlast = parent->firstchild;
while(findlast->nextchild != NULL)
{
findlast = findlast->nextchild;
}
if(findlast->nextchild != child)
findlast->nextchild = child;
}
}
void removeChild(urAPI_Region_t *parent, urAPI_Region_t *child)
{
if(parent->firstchild != NULL)
{
if(parent->firstchild == child)
{
parent->firstchild = parent->firstchild->nextchild;
}
else
{
urAPI_Region_t *findlast = parent->firstchild;
while(findlast->nextchild != NULL && findlast->nextchild != child)
{
findlast = findlast->nextchild;
}
if(findlast->nextchild == child)
{
findlast->nextchild = findlast->nextchild->nextchild;
child->nextchild = NULL;
}
else
{
int a = 0;
}
}
}
}
static int l_Region(lua_State *lua)
{
const char *regiontype = NULL;
const char *regionName = NULL;
urAPI_Region_t *parentRegion = NULL;
if(lua_gettop(lua)>0) // Allow for no arg construction
{
regiontype = luaL_checkstring(lua, 1);
regionName = luaL_checkstring(lua, 2);
// urAPI_Region_t *parentRegion = (urAPI_Region_t*)luaL_checkudata(lua, 4, "URAPI.region");
luaL_checktype(lua, 3, LUA_TTABLE);
lua_rawgeti(lua, 3, 0);
parentRegion = (urAPI_Region_t*)lua_touserdata(lua,4);
luaL_argcheck(lua, parentRegion!= NULL, 4, "'region' expected");
// const char *inheritsRegion = luaL_checkstring(lua, 1); //NYI
}
else
{
parentRegion = UIParent;
}
// NEW!! Return region in a table at index 0
lua_newtable(lua);
luaL_register(lua, NULL, regionfuncs);
// urAPI_Region_t *myregion = (urAPI_Region_t*)lua_newuserdata(lua, sizeof(urAPI_Region_t)); // User data is our value
urAPI_Region_t *myregion = (urAPI_Region_t*)malloc(sizeof(urAPI_Region_t)); // User data is our value
lua_pushlightuserdata(lua, myregion);
// luaL_register(lua, NULL, regionmetas);
// luaL_openlib(lua, 0, regionmetas, 0); /* fill metatable */
lua_rawseti(lua, -2, 0); // Set this to index 0
myregion->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myregion->tableref);
lua_pushliteral(lua, "__gc"); /* mutex destructor */
lua_pushcfunction(lua, region_gc);
lua_rawset(lua, -3);
// ENDNEW!!
// luaL_getmetatable(lua, "URAPI.region");
// lua_setmetatable(lua, -2);
myregion->next = nil;
myregion->parent = parentRegion;
myregion->firstchild = NULL;
myregion->nextchild = NULL;
// addChild(parentRegion, myregion);
// myregion->name = regionName; // NYI
// Link it into the global region list
myregion->name = regionName;
myregion->type = regiontype;
myregion->ofsx = 0.0;
myregion->ofsy = 0.0;
myregion->width = 160.0;
myregion->height = 160.0;
myregion->bottom = 1.0;
myregion->left = 1.0;
myregion->top = myregion->bottom + myregion->height;
myregion->right = myregion->left + myregion->width;
myregion->cx = 80.0;
myregion->cy = 80.0;
myregion->ofsx = 0.0;
myregion->ofsy = 0.0;
myregion->clipleft = 0.0;
myregion->clipbottom = 0.0;
myregion->clipwidth = SCREEN_WIDTH;
myregion->clipheight = SCREEN_HEIGHT;
myregion->alpha = 1.0;
myregion->isMovable = false;
myregion->isResizable = false;
myregion->isTouchEnabled = false;
myregion->isScrollXEnabled = false;
myregion->isScrollYEnabled = false;
myregion->isVisible = false;
myregion->isDragged = false;
myregion->isClamped = false;
myregion->isClipping = false;
myregion->entered = false;
myregion->strata = STRATA_PARENT;
myregion->OnDragStart = 0;
myregion->OnDragStop = 0;
myregion->OnEnter = 0;
myregion->OnEvent = 0;
myregion->OnHide = 0;
myregion->OnLeave = 0;
myregion->OnTouchDown = 0;
myregion->OnTouchUp = 0;
myregion->OnShow = 0;
myregion->OnShow = 0;
myregion->OnSizeChanged = 0; // needs args (NYI)
myregion->OnUpdate = 0;
myregion->OnDoubleTap = 0; // (UR!)
// All UR!
myregion->OnAccelerate = 0;
myregion->OnNetIn = 0;
myregion->OnNetConnect = 0;
myregion->OnNetDisconnect = 0;
#ifdef SANDWICH_SUPPORT
myregion->OnPressure = 0;
#endif
myregion->OnHeading = 0;
myregion->OnLocation = 0;
myregion->OnMicrophone = 0;
myregion->OnHorizontalScroll = 0;
myregion->OnVerticalScroll = 0;
myregion->OnPageEntered = 0;
myregion->OnPageLeft = 0;
myregion->texture = NULL;
myregion->textlabel = NULL;
myregion->point = NULL;
myregion->relativePoint = NULL;
myregion->relativeRegion = NULL;
myregion->page = currentPage;
if(firstRegion[currentPage] == nil) // first region ever
{
firstRegion[currentPage] = myregion;
lastRegion[currentPage] = myregion;
myregion->next = NULL;
myregion->prev = NULL;
}
else
{
myregion->prev = lastRegion[currentPage];
lastRegion[currentPage]->next = myregion;
lastRegion[currentPage] = myregion;
l_setstrataindex(myregion , myregion->strata);
}
// NEW!!
numRegions[currentPage] ++;
// ENDNEW!!
setParent(myregion, parentRegion);
return 1;
}
int flowbox_Name(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushstring(lua, fb->object->name);
return 1;
}
// Object to to PushOut from.
// In to PushOut into.
// Needs ID on specific IN
int flowbox_SetPushLink(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int outindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int inindex = luaL_checknumber(lua, 4);
if(outindex >= fb->object->nr_outs || inindex >= target->object->nr_ins)
{
return 0;
}
fb->object->AddPushOut(outindex, &target->object->ins[inindex]);
lua_pushboolean(lua, 1);
return 1;
}
int flowbox_SetPullLink(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int inindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int outindex = luaL_checknumber(lua, 4);
if(inindex >= fb->object->nr_ins || outindex >= target->object->nr_outs)
{
return 0;
}
fb->object->AddPullIn(inindex, &target->object->outs[outindex]);
if(!strcmp(fb->object->name,dacobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveDacTickSinkList.AddSink(&target->object->outs[outindex]);
if(!strcmp(fb->object->name,visobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveVisTickSinkList.AddSink(&target->object->outs[outindex]);
if(!strcmp(fb->object->name,netobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveNetTickSinkList.AddSink(&target->object->outs[outindex]);
lua_pushboolean(lua, 1);
return 1;
}
int flowbox_IsPushed(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int outindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int inindex = luaL_checknumber(lua, 4);
if(outindex >= fb->object->nr_outs || inindex >= target->object->nr_ins)
{
return 0;
}
if(fb->object->IsPushedOut(outindex, &target->object->ins[inindex]))
{
lua_pushboolean(lua,1);
return 1;
}
else
return 0;
}
int flowbox_IsPulled(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int inindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int outindex = luaL_checknumber(lua, 4);
if(inindex >= fb->object->nr_ins || outindex >= target->object->nr_outs)
{
return 0;
}
if(fb->object->IsPulledIn(inindex, &target->object->outs[outindex]))
{
lua_pushboolean(lua, 1);
return 1;
}
else
return 0;
}
int flowbox_RemovePushLink(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int outindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int inindex = luaL_checknumber(lua, 4);
if(outindex >= fb->object->nr_outs || inindex >= target->object->nr_ins)
{
return 0;
}
fb->object->RemovePushOut(outindex, &target->object->ins[inindex]);
lua_pushboolean(lua, 1);
return 1;
}
int flowbox_RemovePullLink(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int inindex = luaL_checknumber(lua,2);
ursAPI_FlowBox_t* target = checkflowbox(lua, 3);
int outindex = luaL_checknumber(lua, 4);
if(inindex >= fb->object->nr_ins || outindex >= target->object->nr_outs)
{
return 0;
}
fb->object->RemovePullIn(inindex, &target->object->outs[outindex]);
if(!strcmp(fb->object->name,dacobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveDacTickSinkList.RemoveSink(&target->object->outs[outindex]);
if(!strcmp(fb->object->name,visobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveVisTickSinkList.RemoveSink(&target->object->outs[outindex]);
if(!strcmp(fb->object->name,netobject->name)) // This is hacky and should be done differently. Namely in the sink pulling
urActiveNetTickSinkList.RemoveSink(&target->object->outs[outindex]);
lua_pushboolean(lua, 1);
return 1;
}
int flowbox_IsPushing(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int index = luaL_checknumber(lua,2);
lua_pushboolean(lua, fb->object->firstpullin[index]!=NULL);
return 1;
}
int flowbox_IsPulling(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int index = luaL_checknumber(lua,2);
lua_pushboolean(lua, fb->object->firstpushout[index]!=NULL);
return 1;
}
int flowbox_IsPlaced(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int index = luaL_checknumber(lua,2);
lua_pushboolean(lua, fb->object->ins[index].isplaced);
return 1;
}
int flowbox_NumIns(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushnumber(lua, fb->object->nr_ins);
return 1;
}
int flowbox_NumOuts(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushnumber(lua, fb->object->nr_outs);
return 1;
}
int flowbox_Ins(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int nrins = fb->object->lastin;
for(int j=0; j< nrins; j++)
// if(fb->object->ins[j].name!=(void*)0x1)
lua_pushstring(lua, fb->object->ins[j].name);
// else {
// int a=2;
// }
return nrins;
}
int flowbox_Outs(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
int nrouts = fb->object->lastout;
for(int j=0; j< nrouts; j++)
lua_pushstring(lua, fb->object->outs[j].name);
return nrouts;
}
int flowbox_Push(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
float indata = luaL_checknumber(lua, 2);
fb->object->CallAllPushOuts(indata);
/* if(fb->object->firstpushout[0]!=NULL)
{
ursObject* inobject;
urSoundPushOut* pushto = fb->object->firstpushout[0];
for(;pushto!=NULL; pushto = pushto->next)
{
urSoundIn* in = pushto->in;
inobject = in->object;
in->inFuncTick(inobject, indata);
}
}*/
// callAllPushSources(indata);
return 0;
}
int flowbox_Pull(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
float indata = luaL_checknumber(lua, 2);
fb->object->CallAllPushOuts(indata);
return 0;
}
extern double visoutdata;
int flowbox_Get(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
// float indata = luaL_checknumber(lua, 2);
lua_pushnumber(lua, visoutdata);
return 1;
}
int flowbox_AddFile(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
const char* filename = luaL_checkstring(lua, 2);
if(!strcmp(fb->object->name, "Sample"))
{
Sample_AddFile(fb->object, filename);
}
}
int flowbox_IsInstantiable(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushboolean(lua, !fb->object->noninstantiable);
return 1;
}
int flowbox_InstanceNumber(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushnumber(lua, fb->object->instancenumber);
return 1;
}
int flowbox_NumberInstances(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushnumber(lua, fb->object->instancelist->Last());
return 1;
}
int flowbox_Couple(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
if(fb->object->iscoupled)
{
lua_pushnumber(lua, fb->object->couple_in);
lua_pushnumber(lua, fb->object->couple_out);
return 2;
}
else
return 0;
}
int flowbox_IsCoupled(lua_State *lua)
{
ursAPI_FlowBox_t* fb = checkflowbox(lua, 1);
lua_pushboolean(lua, fb->object->iscoupled);
return 1;
}
// Methods table for the flowbox API
static const struct luaL_reg flowboxfuncs [] =
{
{"Name", flowbox_Name},
{"NumIns", flowbox_NumIns},
{"NumOuts", flowbox_NumOuts},
{"Ins", flowbox_Ins},
{"Outs", flowbox_Outs},
{"SetPushLink", flowbox_SetPushLink},
{"SetPullLink", flowbox_SetPullLink},
{"RemovePushLink", flowbox_RemovePushLink},
{"RemovePullLink", flowbox_RemovePullLink},
{"IsPushed", flowbox_IsPushed},
{"IsPulled", flowbox_IsPulled},
{"Push", flowbox_Push},
{"Pull", flowbox_Pull},
{"Get", flowbox_Get},
{"AddFile", flowbox_AddFile},
{"IsInstantiable", flowbox_IsInstantiable},
{"InstanceNumber", flowbox_InstanceNumber},
{"NumberInstances", flowbox_NumberInstances},
{"Couple", flowbox_Couple},
{"IsCoupled", flowbox_IsCoupled},
{NULL, NULL}
};
static int l_FlowBox(lua_State* lua)
{
const char *flowboxtype = luaL_checkstring(lua, 1);
const char *flowboxName = luaL_checkstring(lua, 2);
// urAPI_flowbox_t *parentflowbox = (urAPI_flowbox_t*)luaL_checkudata(lua, 4, "URAPI.flowbox");
luaL_checktype(lua, 3, LUA_TTABLE);
lua_rawgeti(lua, 3, 0);
ursAPI_FlowBox_t *parentFlowBox = (ursAPI_FlowBox_t*)lua_touserdata(lua,4);
luaL_argcheck(lua, parentFlowBox!= NULL, 4, "'flowbox' expected");
// const char *inheritsflowbox = luaL_checkstring(lua, 1); //NYI
// NEW!! Return flowbox in a table at index 0
lua_newtable(lua);
luaL_register(lua, NULL, flowboxfuncs);
ursAPI_FlowBox_t *myflowbox = (ursAPI_FlowBox_t*)malloc(sizeof(ursAPI_FlowBox_t)); // User data is our value
lua_pushlightuserdata(lua, myflowbox);
lua_rawseti(lua, -2, 0); // Set this to index 0
myflowbox->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myflowbox->tableref);
myflowbox->object = parentFlowBox->object->Clone();
// myflowbox->object->instancenumber = parentFlowBox->object->instancenumber + 1;
// ENDNEW!!
// luaL_getmetatable(lua, "URAPI.flowbox");
// lua_setmetatable(lua, -2);
return 1;
}
void ur_GetSoundBuffer(SInt32* buffer, int channel, int size)
{
lua_getglobal(lua,"urSoundData");
lua_rawgeti(lua, -1, channel);
if(lua_isnil(lua, -1) || !lua_istable(lua,-1)) // Channel doesn't exist or is falsely set up
{
lua_pop(lua,1);
return;
}
for(int i=0; i<size; i++)
{
lua_rawgeti(lua, -1, i+1);
if(lua_isnumber(lua, -1))
buffer[i] = lua_tonumber(lua, -1);
lua_pop(lua,1);
}
lua_pop(lua, 2);
}
int l_SourceNames(lua_State *lua)
{
int nr = urs_NumUrSourceObjects();
for(int i=0; i<nr; i++)
{
lua_pushstring(lua, urs_GetSourceObjectName(i));
}
return nr;
}
int l_ManipulatorNames(lua_State *lua)
{
int nr = urs_NumUrManipulatorObjects();
for(int i=0; i<nr; i++)
{
lua_pushstring(lua, urs_GetManipulatorObjectName(i));
}
return nr;
}
int l_SinkNames(lua_State *lua)
{
int nr = urs_NumUrSinkObjects();
for(int i=0; i<nr; i++)
{
lua_pushstring(lua, urs_GetSinkObjectName(i));
}
return nr;
}
#ifdef ALLOW_DEFUNCT
int l_NumUrIns(lua_State *lua)
{
const char* obj = luaL_checkstring(lua, 1);
int nr = urs_NumUrManipulatorObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetManipulatorObjectName(i)))
{
lua_pushnumber(lua, urs_NumUrManipulatorIns(i));
return 1;
}
}
nr = urs_NumUrSinkObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetSinkObjectName(i)))
{
lua_pushnumber(lua, urs_NumUrSinkIns(i));
return 1;
}
}
return 0;
}
int l_NumUrOuts(lua_State *lua)
{
const char* obj = luaL_checkstring(lua, 1);
int nr = urs_NumUrSourceObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetSourceObjectName(i)))
{
lua_pushnumber(lua, urs_NumUrSourceOuts(i));
return 1;
}
}
nr = urs_NumUrManipulatorObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetManipulatorObjectName(i)))
{
lua_pushnumber(lua, urs_NumUrManipulatorOuts(i));
return 1;
}
}
return 0;
}
int l_GetUrIns(lua_State *lua)
{
const char* obj = luaL_checkstring(lua, 1);
int nr = urs_NumUrManipulatorObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetManipulatorObjectName(i)))
{
int nrins = urs_NumUrManipulatorIns(i);
for(int j=0; j< nrins; j++)
lua_pushstring(lua, urs_GetManipulatorIn(i, j));
return nrins;
}
}
nr = urs_NumUrSinkObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetSinkObjectName(i)))
{
int nrins = urs_NumUrSinkIns(i);
for(int j=0; j< nrins; j++)
lua_pushstring(lua, urs_GetSinkIn(i, j));
return nrins;
}
}
return 0;
}
int l_GetUrOuts(lua_State *lua)
{
const char* obj = luaL_checkstring(lua, 1);
int nr = urs_NumUrSourceObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetSourceObjectName(i)))
{
int nrouts = urs_NumUrSourceOuts(i);
for(int j=0; j< nrouts; j++)
lua_pushstring(lua, urs_GetSourceOut(i, j));
return nrouts;
}
}
nr = urs_NumUrManipulatorObjects();
for(int i=0; i<nr; i++)
{
if(!strcmp(obj, urs_GetManipulatorObjectName(i)))
{
int nrouts = urs_NumUrManipulatorOuts(i);
for(int j=0; j< nrouts; j++)
lua_pushstring(lua, urs_GetManipulatorOut(i, j));
return nrouts;
}
}
return 0;
}
#endif
int l_SystemPath(lua_State *lua)
{
#ifdef TARGET_IPHONE
const char* filename = luaL_checkstring(lua,1);
NSString *filename2 = [[NSString alloc] initWithCString:filename];
NSString *filePath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:filename2];
const char* filestr = [filePath UTF8String];
lua_pushstring(lua, filestr);
#else
// TODO // find system path
#endif
return 1;
}
int l_DocumentPath(lua_State *lua)
{
#ifdef TARGET_IPHONE
const char* filename = luaL_checkstring(lua,1);
NSString *filename2 = [[NSString alloc] initWithCString:filename];
NSArray *paths;
paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
if ([paths count] > 0) {
NSString *filePath = [paths objectAtIndex:0];
NSString *resultPath = [NSString stringWithFormat:@"%@/%@", filePath, filename2];
const char* filestr = [resultPath UTF8String];
lua_pushstring(lua, filestr);
}
else
{
luaL_error(lua, "Cannot find the Document path.");
}
#else
// TODO // find document path
#endif
return 1;
}
int l_NumMaxPages(lua_State *lua)
{
int max = MAX_PAGES;
lua_pushnumber(lua, max);
return 1;
}
int l_Page(lua_State *lua)
{
lua_pushnumber(lua, currentPage+1);
return 1;
}
int l_SetPage(lua_State *lua)
{
int oldcurrent;
int num = luaL_checknumber(lua,1);
if(num >= 1 and num <= MAX_PAGES)
{
callAllOnPageLeft(num-1);
oldcurrent = currentPage;
currentPage = num-1;
callAllOnPageEntered(oldcurrent);
}
else
{
// Error!!
luaL_error(lua, "Invalid page number: %d",num);
}
return 0;
}
//------------------------------------------------------------------------------
// Register our API
//------------------------------------------------------------------------------
void l_setupAPI(lua_State *lua)
{
#ifdef TARGET_IPHONE
CGRect screendimensions = [[UIScreen mainScreen] bounds];
SCREEN_WIDTH = screendimensions.size.width;
SCREEN_HEIGHT = screendimensions.size.height;
#else
// for android, SCREEN_WIDTH and SCREEN_HEIGHT are set up in urMus.init(int,int) native function
#endif
// Set global userdata
// Create UIParent
// luaL_newmetatable(lua, "URAPI.region");
// lua_pushstring(lua, "__index");
// lua_pushvalue(lua, -2);
// lua_settable(lua, -3);
// luaL_openlib(lua, NULL, regionfuncs, 0);
lua_newtable(lua);
luaL_register(lua, NULL, regionfuncs);
// urAPI_Region_t *myregion = (urAPI_Region_t*)lua_newuserdata(lua, sizeof(urAPI_Region_t)); // User data is our value
urAPI_Region_t *myregion = (urAPI_Region_t*)malloc(sizeof(urAPI_Region_t)); // User data is our value
lua_pushlightuserdata(lua, myregion);
lua_rawseti(lua, -2, 0); // Set this to index 0
myregion->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myregion->tableref);
// luaL_getmetatable(lua, "URAPI.region");
// lua_setmetatable(lua, -2);
myregion->strata = STRATA_BACKGROUND;
myregion->parent = NULL;
myregion->top = SCREEN_HEIGHT;
myregion->bottom = 0;
myregion->left = 0;
myregion->right = SCREEN_WIDTH;
myregion->cx = SCREEN_WIDTH/2;
myregion->cy = SCREEN_HEIGHT/2;
myregion->firstchild = NULL;
myregion->point = NULL;
myregion->relativePoint = NULL;
UIParent = myregion;
lua_setglobal(lua, "UIParent");
urs_SetupObjects();
char fbname[255];
for(int source=0; source<ursourceobjectlist.Last(); source++)
{
lua_newtable(lua);
luaL_register(lua, NULL, flowboxfuncs);
ursAPI_FlowBox_t *myflowbox = (ursAPI_FlowBox_t*)malloc(sizeof(ursAPI_FlowBox_t)); // User data is our value
lua_pushlightuserdata(lua, myflowbox);
lua_rawseti(lua, -2, 0); // Set this to index 0
myflowbox->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myflowbox->tableref);
// luaL_getmetatable(lua, "URAPI.region");
// lua_setmetatable(lua, -2);
myflowbox->object = ursourceobjectlist[source];
FBNope = myflowbox;
strcpy(fbname, "FB");
strcat(fbname, myflowbox->object->name);
lua_setglobal(lua, fbname);
}
for(int manipulator=0; manipulator<urmanipulatorobjectlist.Last(); manipulator++)
{
lua_newtable(lua);
luaL_register(lua, NULL, flowboxfuncs);
ursAPI_FlowBox_t *myflowbox = (ursAPI_FlowBox_t*)malloc(sizeof(ursAPI_FlowBox_t)); // User data is our value
lua_pushlightuserdata(lua, myflowbox);
lua_rawseti(lua, -2, 0); // Set this to index 0
myflowbox->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myflowbox->tableref);
// luaL_getmetatable(lua, "URAPI.region");
// lua_setmetatable(lua, -2);
myflowbox->object = urmanipulatorobjectlist[manipulator];
FBNope = myflowbox;
strcpy(fbname, "FB");
strcat(fbname, myflowbox->object->name);
lua_setglobal(lua, fbname);
}
for(int sink=0; sink<ursinkobjectlist.Last(); sink++)
{
lua_newtable(lua);
luaL_register(lua, NULL, flowboxfuncs);
ursAPI_FlowBox_t *myflowbox = (ursAPI_FlowBox_t*)malloc(sizeof(ursAPI_FlowBox_t)); // User data is our value
lua_pushlightuserdata(lua, myflowbox);
lua_rawseti(lua, -2, 0); // Set this to index 0
myflowbox->tableref = luaL_ref(lua, LUA_REGISTRYINDEX);
lua_rawgeti(lua, LUA_REGISTRYINDEX, myflowbox->tableref);
// luaL_getmetatable(lua, "URAPI.region");
// lua_setmetatable(lua, -2);
myflowbox->object = ursinkobjectlist[sink];
FBNope = myflowbox;
strcpy(fbname, "FB");
strcat(fbname, myflowbox->object->name);
lua_setglobal(lua, fbname);
}
luaL_newmetatable(lua, "URAPI.texture");
lua_pushstring(lua, "__index");
lua_pushvalue(lua, -2);
lua_settable(lua, -3);
// luaL_openlib(lua, NULL, texturefuncs, 0);
luaL_register(lua, NULL, texturefuncs);
luaL_newmetatable(lua, "URAPI.textlabel");
lua_pushstring(lua, "__index");
lua_pushvalue(lua, -2);
lua_settable(lua, -3);
// luaL_openlib(lua, NULL, textlabelfuncs, 0);
luaL_register(lua, NULL, textlabelfuncs);
// Compats
lua_pushcfunction(lua, l_Region);
lua_setglobal(lua, "Region");
// NEW!!
lua_pushcfunction(lua, l_NumRegions);
lua_setglobal(lua, "NumRegions");
// ENDNEW!!
lua_pushcfunction(lua, l_InputFocus);
lua_setglobal(lua, "InputFocus");
lua_pushcfunction(lua, l_HasInput);
lua_setglobal(lua, "HasInput");
lua_pushcfunction(lua, l_InputPosition);
lua_setglobal(lua, "InputPosition");
lua_pushcfunction(lua, l_ScreenHeight);
lua_setglobal(lua, "ScreenHeight");
lua_pushcfunction(lua, l_ScreenWidth);
lua_setglobal(lua, "ScreenWidth");
lua_pushcfunction(lua, l_Time);
lua_setglobal(lua, "Time");
lua_pushcfunction(lua, l_RunScript);
lua_setglobal(lua, "RunScript");
lua_pushcfunction(lua,l_StartAudio);
lua_setglobal(lua,"StartAudio");
lua_pushcfunction(lua,l_PauseAudio);
lua_setglobal(lua,"PauseAudio");
// HTTP
lua_pushcfunction(lua,l_StartHTTPServer);
lua_setglobal(lua,"StartHTTPServer");
lua_pushcfunction(lua,l_StopHTTPServer);
lua_setglobal(lua,"StopHTTPServer");
lua_pushcfunction(lua,l_HTTPServer);
lua_setglobal(lua,"HTTPServer");
// UR!
lua_pushcfunction(lua, l_setanimspeed);
lua_setglobal(lua, "SetFrameRate");
lua_pushcfunction(lua, l_DPrint);
lua_setglobal(lua, "DPrint");
// URSound!
lua_pushcfunction(lua, l_SourceNames);
lua_setglobal(lua, "SourceNames");
lua_pushcfunction(lua, l_ManipulatorNames);
lua_setglobal(lua, "ManipulatorNames");
lua_pushcfunction(lua, l_SinkNames);
lua_setglobal(lua, "SinkNames");
#ifdef ALLOW_DEFUNCT
lua_pushcfunction(lua, l_NumUrIns);
lua_setglobal(lua, "NumUrIns");
lua_pushcfunction(lua, l_NumUrOuts);
lua_setglobal(lua, "NumUrOuts");
lua_pushcfunction(lua, l_GetUrIns);
lua_setglobal(lua, "GetUrIns");
lua_pushcfunction(lua, l_GetUrOuts);
lua_setglobal(lua, "GetUrOuts");
#endif
lua_pushcfunction(lua, l_FlowBox);
lua_setglobal(lua, "FlowBox");
lua_pushcfunction(lua, l_SystemPath);
lua_setglobal(lua, "SystemPath");
lua_pushcfunction(lua, l_DocumentPath);
lua_setglobal(lua, "DocumentPath");
lua_pushcfunction(lua, l_NumMaxPages);
lua_setglobal(lua, "NumMaxPages");
lua_pushcfunction(lua, l_Page);
lua_setglobal(lua, "Page");
lua_pushcfunction(lua, l_SetPage);
lua_setglobal(lua, "SetPage");
lua_pushcfunction(lua, l_FreeAllRegions);
lua_setglobal(lua, "FreeAllRegions");
// Initialize the global mic buffer table
#ifdef MIC_ARRAY
lua_newtable(lua);
lua_setglobal(lua, "urMicData");
#endif
#ifdef SOUND_ARRAY
// NOTE: SOMETHING IS WEIRD HERE. CAUSES VARIOUS BUGS IF ONE WRITES TO THIS TABLE
lua_newtable(lua);
lua_newtable(lua);
lua_rawseti(lua, -2, 1); // Setting up for stereo for now
lua_newtable(lua);
lua_rawseti(lua, -2, 2); // Can be extended to any number of channels here
lua_setglobal(lua,"urSoundData");
#endif
#ifdef TARGET_IPHONE
systimer = [MachTimer alloc];
[systimer start];
#else
systimer = new MachTimer();
systimer->start();
#endif
}
| 24.34138 | 132 | 0.694021 | jongwook |
b4ab7508b8b65363e2c87d6b37e60967ec9bd4da | 2,552 | cpp | C++ | SimpleEngine/Main.cpp | RichardBangs/SimpleEngine | a4acdf11d05e018db5a55994291475df55856c0c | [
"MIT"
] | null | null | null | SimpleEngine/Main.cpp | RichardBangs/SimpleEngine | a4acdf11d05e018db5a55994291475df55856c0c | [
"MIT"
] | null | null | null | SimpleEngine/Main.cpp | RichardBangs/SimpleEngine | a4acdf11d05e018db5a55994291475df55856c0c | [
"MIT"
] | null | null | null |
#include "glew.h"
#include "freeglut.h"
#include "glm.hpp"
#include "Path.h"
#include "Renderer\RenderableManager.h"
#include "Renderer\Camera.h"
#include "Renderer\ShaderLoader.h"
#include "Renderer\WindowManager.h"
#include "Game\InputManager.h"
#include "Game\GameManager.h"
#include <iostream>
#include <vector>
extern void SetupOpenGLWindow(int argc, char** argv);
extern void OnKeyboardInput(unsigned char key, int x, int y);
extern void OnMouseInput(int button, int state, int x, int y);
extern void OnRender();
extern void SetupScene();
extern void OnClose();
extern void OnTick(int timerId);
Game::GameManager* gameManager;
int main(int argc, char** argv)
{
SetupOpenGLWindow( argc, argv );
return 0;
}
void SetupOpenGLWindow(int argc, char** argv)
{
const int windowWidth = 1600;
const int windowHeight = 800;
const float aspectRatio = (float)windowHeight / windowWidth;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
Renderer::WindowManager::Create();
Renderer::WindowManager::Instance().InitialiseWindow(glm::vec2(100, 100), glm::vec2(windowWidth, windowHeight));
glewInit();
if (glewIsSupported("GL_VERSION_4_5"))
{
std::cout << "GLEW Version 4.5 is supported." << std::endl;
}
else
{
std::cout << "ERROR - GLEW 4.5 Not Supported" << std::endl;
int temp;
std::cin >> temp;
return;
}
glEnable(GL_DEPTH_TEST);
glutKeyboardFunc(OnKeyboardInput);
glutMouseFunc(OnMouseInput);
glutDisplayFunc(OnRender);
glutCloseFunc(OnClose);
glutTimerFunc(1, OnTick, 0);
Renderer::RenderableManager::Create();
Renderer::Camera::Create();
Renderer::Camera::Instance().Scale = glm::vec3(aspectRatio, 1.0f, 1.0f);
gameManager = new Game::GameManager();
glutMainLoop();
}
void OnKeyboardInput(unsigned char key, int x, int y)
{
Game::InputManager::Instance().OnKeyboardInput(key);
}
void OnMouseInput(int button, int state, int x, int y)
{
Game::InputManager::Instance().OnMouseInput(button, state, x, y);
}
void OnUpdate(float dt)
{
gameManager->OnUpdate( dt );
}
void OnRender()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
Renderer::RenderableManager::Instance().Render();
gameManager->OnRender();
glutSwapBuffers();
}
void OnTick(int timerId)
{
OnUpdate(1.0f/60.0f);
OnRender();
glutTimerFunc(1000 / 60, OnTick, 0);
}
void OnClose()
{
glutLeaveMainLoop();
delete gameManager;
Renderer::RenderableManager::Destroy();
Renderer::Camera::Destroy();
Renderer::ShaderLoader::DestroyAllShaders();
} | 20.580645 | 113 | 0.723354 | RichardBangs |
b4ac5ff96fde73b7daa9d1da116a7917e99ad54c | 21,270 | hpp | C++ | lib/include/base_dkg.hpp | fetchai/research-dvrf | 943b335e1733bb9b2ef403e4f8237dfdc4f93952 | [
"Apache-2.0"
] | 16 | 2020-02-08T00:04:58.000Z | 2022-01-18T11:42:07.000Z | lib/include/base_dkg.hpp | fetchai/research-dvrf | 943b335e1733bb9b2ef403e4f8237dfdc4f93952 | [
"Apache-2.0"
] | null | null | null | lib/include/base_dkg.hpp | fetchai/research-dvrf | 943b335e1733bb9b2ef403e4f8237dfdc4f93952 | [
"Apache-2.0"
] | 4 | 2021-07-20T08:56:08.000Z | 2022-01-03T01:48:12.000Z | #pragma once
//------------------------------------------------------------------------------
//
// Copyright 2019-2020 Fetch.AI Limited
//
// 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 <array>
#include <unordered_map>
#include <cstdint>
#include <cstddef>
#include <iostream>
#include <mutex>
#include "consensus.pb.h"
#include "group_signature_manager.hpp"
#include "messages.hpp"
namespace fetch {
namespace consensus {
/**
* This class implemnents defines the functions required for the DKG
*/
template<class CryptoType, class CryptoVerificationKey>
class BaseDkg {
public:
using PrivateKey = typename CryptoType::PrivateKey;
using Signature = typename CryptoType::Signature;
using GroupPublicKey = typename CryptoType::GroupPublicKey;
using VerificationKey = CryptoVerificationKey;
using MessagePayload = std::string;
struct DkgOutput {
GroupPublicKey groupPublicKey;
std::vector<VerificationKey> publicKeyShares;
PrivateKey privateKey;
DkgOutput(GroupPublicKey groupPublicKey1, std::vector<VerificationKey> publicKeyShares1,
const PrivateKey &privateKey1)
: groupPublicKey{std::move(groupPublicKey1)}, publicKeyShares{std::move(publicKeyShares1)},
privateKey{privateKey1} {}
};
BaseDkg(uint32_t committeeSize, uint32_t threshold) : committeeSize_{committeeSize}, polynomialDegree_{threshold - 1},
groupSignatureManager_{threshold} {
static bool once = []() {
CryptoType::initCrypto();
return true;
}();
CryptoType::setGenerators(this->G, this->H);
if (!once) {
std::cerr << "Node::initPairing failed.\n"; // just to eliminate warnings from the compiler.
}
this->publicKeyShares_.resize(this->committeeSize_);
init(this->C_ik_, this->committeeSize_, this->polynomialDegree_ + 1);
init(this->A_ik_, this->committeeSize_, this->polynomialDegree_ + 1);
init(this->s_ij_, this->committeeSize_, this->committeeSize_);
init(this->sprime_ij_, this->committeeSize_, this->committeeSize_);
init(this->g__s_ij_, this->committeeSize_, this->committeeSize_);
}
virtual ~BaseDkg() = default;
virtual std::pair<fetch::consensus::pb::Broadcast, std::vector<fetch::consensus::pb::PrivateShares>>
createCoefficientsAndShares(uint32_t rank) = 0;
virtual void computeQualCoefficient(fetch::consensus::pb::Broadcast_Coefficients &coefs, uint32_t rank) = 0;
virtual bool setQualCoefficient(uint32_t from, uint32_t i, const std::string &coef) = 0;
virtual bool verifyQualCoefficient(uint32_t rank, uint32_t i) const = 0;
virtual std::pair<bool, bool> verifyQualComplaint(uint32_t nodeIndex, uint32_t fromIndex, const std::string &first,
const std::string &second) = 0;
virtual bool runReconstruction(const std::unordered_map<std::string, uint32_t> &nodesMap) = 0;
virtual void
computePublicKeys(const std::set<std::string> &qual, const std::unordered_map<std::string, uint32_t> &nodesMap) = 0;
virtual SignaturesShare getSignatureShare(const MessagePayload &message, uint32_t rank) = 0;
virtual bool
addSignatureShare(const fetch::consensus::pb::Gossip_SignatureShare &share_msg, uint32_t miner_index) = 0;
/**
* Adds new shares from another DKG member
*
* @param from Index of the sender
* @param rank Our index
* @param shares The private shares message received from the sender
* @return bool indicating whether the shares deserialised correctly
*/
bool setShare(uint32_t from, uint32_t rank, const fetch::consensus::pb::PrivateShares &shares) {
return s_ij_[from][rank].assign(shares.first()) && sprime_ij_[from][rank].assign(shares.second());
}
/**
* Add new coeffcients
*
* @param from Index of the sender
* @param i Index in vector of coefficients
* @param coef Value of coefficient vector at index i as string
* @return bool indicating whether coefficient deserialised correctly
*/
bool setCoefficient(uint32_t from, uint32_t i, const std::string &coef) {
if (C_ik_[from][i].isZero()) {
return C_ik_[from][i].assign(coef);
}
return false;
}
/**
* Checks coefficients broadcasted by cabinet member c_i is consistent with the secret shares
* received from c_i. If false then add to complaints
*
* @return Set of muddle addresses of nodes we complain against
*/
std::set<std::string> computeComplaints(const std::set<std::string> &miners, uint32_t rank) {
std::set<std::string> complaints_local;
uint32_t i = 0;
for (auto &miner : miners) {
if (i != rank) {
if (!C_ik_[i][0].isZero() && !s_ij_[i][rank].isZero()) {
VerificationKey rhs, lhs;
lhs = computeLHS(g__s_ij_[i][rank], G, H, s_ij_[i][rank], sprime_ij_[i][rank]);
rhs = computeRHS(rank, C_ik_[i]);
if (lhs != rhs)
complaints_local.insert(miner);
} else {
complaints_local.insert(miner);
}
}
++i;
}
return complaints_local;
}
/**
* Broadcast private shares after processing complaints
*
* @param shares Shares msg to be broadcasted
* @param reporter String id of the complaint filer
* @param from Owner of original shares
* @param to Recipient of original shares
*/
void broadcastShare(fetch::consensus::pb::Broadcast_Shares &shares, const std::string &reporter,
uint32_t from, uint32_t to) const {
shares.add_first(s_ij_[from][to].toString());
shares.add_second(sprime_ij_[from][to].toString());
shares.add_reporter(reporter);
}
/**
* Verify private shares received
*
* @param reporterIndex Index of member filing complaint
* @param fromIndex Index of the sender of the shares
* @param rank Our index
* @param first First share as string
* @param second Second share as string
* @return bool for whether the shares pass verification with broadcasted coefficients
*/
bool verifyShare(uint32_t reporterIndex, uint32_t fromIndex, uint32_t rank, const std::string &first,
const std::string &second) {
PrivateKey s, sprime;
VerificationKey lhsG, rhsG;
if (s.assign(first) && sprime.assign(second)) {
rhsG = computeRHS(reporterIndex, C_ik_[fromIndex]);
lhsG = computeLHS(G, H, s, sprime);
if (lhsG == rhsG) {
if (reporterIndex == rank) {
s_ij_[fromIndex][rank] = s;
sprime_ij_[fromIndex][rank] = sprime;
g__s_ij_[fromIndex][rank].setZero();
g__s_ij_[fromIndex][rank].mult(G, s_ij_[fromIndex][rank]);
}
return true;
}
return false;
}
return false;
}
/**
* Compute own private key
*
* @param rank Our index
* @param quals Indices of qualified members
*/
void computePrivateKey(uint32_t rank, const std::vector<uint32_t> &quals) {
std::lock_guard<std::mutex> lock(mutex_);
privateKey_.setZero();
xprime_i_.setZero();
for (auto &iq_index : quals) {
privateKey_.add(privateKey_, s_ij_[iq_index][rank]);
xprime_i_.add(xprime_i_, sprime_ij_[iq_index][rank]);
}
}
/**
* Inserting reconstruction shares
*
* @param id String id of member being reconstructed
* @param index Index of member being reconstructed
* @param rank Our index
*/
void newReconstructionShare(const std::string &id, uint32_t index, uint32_t rank) {
std::lock_guard<std::mutex> lock(mutex_);
if (reconstructionShares_.find(id) == reconstructionShares_.end()) {
reconstructionShares_.insert({id, {{}, std::vector<PrivateKey>(committeeSize_)}});
}
reconstructionShares_.at(id).first.insert(rank);
reconstructionShares_.at(id).second[rank] = s_ij_[index][rank];
}
/**
* Verify reconstruction shares received
*
* @param nodeIndex Index of node who is being reconstructed
* @param fromIndex Index of the sender of the shares
* @param reporter Index of the person filing complaint
* @param first First secret share as string
* @param second Second secret share as string
*/
void verifyReconstructionShare(uint32_t nodeIndex, uint32_t fromIndex, const std::string &reporter,
const std::string &first,
const std::string &second) {
std::lock_guard<std::mutex> lock(mutex_);
VerificationKey lhs, rhs;
PrivateKey s, sprime;
if (s.assign(first) and sprime.assign(second)) {
lhs = computeLHS(G, H, s, sprime);
rhs = computeRHS(fromIndex, C_ik_[nodeIndex]);
bool check = lhs == rhs;
if (check) {
if (reconstructionShares_.find(reporter) == reconstructionShares_.end()) {
reconstructionShares_.insert(
{reporter, {{}, std::vector<PrivateKey>(committeeSize_)}});
} else if (reconstructionShares_.at(reporter).second[fromIndex].isZero()) {
return;
}
reconstructionShares_.at(reporter).first.insert(fromIndex); // good share received
reconstructionShares_.at(reporter).second[fromIndex] = s;
}
}
}
std::string computeGroupSignature(const MessagePayload &message) {
std::lock_guard<std::mutex> lock(mutex_);
assert(groupSignatureManager_.numSignatureShares(message) > polynomialDegree_);
Signature sig{lagrangeInterpolation(groupSignatureManager_.signatureShares(message))};
groupSignatureManager_.addSignedMessage(message, sig);
return sig.toString();
}
void setDkgOutput(const DkgOutput &output) {
std::lock_guard<std::mutex> lock(mutex_);
groupPublicKey_ = output.groupPublicKey;
privateKey_ = output.privateKey;
for (size_t i = 0; i < publicKeyShares_.size(); i++) {
publicKeyShares_[i] = output.publicKeyShares[i];
}
}
/// Getter functions
/// @{
std::string groupPublicKey() const {
if (groupPublicKey_.isZero()) {
return "";
}
return groupPublicKey_.toString();
}
std::vector<std::string> publicKeyShares() const {
std::vector<std::string> public_key_shares;
for (uint32_t i = 0; i < committeeSize_; ++i) {
assert(!publicKeyShares_[i].isZero());
public_key_shares.push_back(publicKeyShares_[i].toString());
assert(!public_key_shares[i].empty());
}
return public_key_shares;
}
/// @}
/// Threshold Signing Methods
/// @{
std::string groupSignature(const MessagePayload &message) const {
return groupSignatureManager_.groupSignature(message);
}
bool groupSignatureCompleted(const MessagePayload &message) const {
return groupSignatureManager_.signatureCompleted(message);
}
size_t numSignatureShares(const MessagePayload &message) const {
return groupSignatureManager_.numSignatureShares(message);
}
bool isFinished(const MessagePayload &message) const {
return groupSignatureManager_.numSignatureShares(message) > polynomialDegree_;
}
/// @}
static void initCrypto() {
CryptoType::initCrypto();
}
template<class Generator>
static void setGenerator(Generator &generator) {
CryptoType::setGenerator(generator);
}
template<class Generator>
static void setGenerators(Generator &generator1, Generator &generator2) {
CryptoType::setGenerators(generator1, generator2);
}
/**
* Computes signature share of a message
*
* @param message Message to be signed
* @param privateKey Secret key share
* @return Signature share
*/
static Signature sign(const MessagePayload &message, const PrivateKey &privateKey) {
Signature PH;
Signature sign;
PH.hashAndMap(message);
sign.mult(PH, privateKey);
return sign;
}
/**
* Computes the group signature using the indices and signature shares of threshold_ + 1
* parties
*
* @param shares Unordered map of indices and their corresponding signature shares
* @return Group signature
*/
static Signature lagrangeInterpolation(const std::unordered_map<uint32_t, typename CryptoType::Signature> &shares) {
assert(!shares.empty());
if (shares.size() == 1) {
return shares.begin()->second;
}
Signature res;
PrivateKey a{1};
for (auto &p : shares) {
a.mult(a, typename CryptoType::PrivateKey{uint32_t(p.first + 1)});
}
for (auto &p1 : shares) {
typename CryptoType::PrivateKey b{uint32_t(p1.first + 1)};
for (auto &p2 : shares) {
if (p2.first != p1.first) {
typename CryptoType::PrivateKey local_share1{uint32_t(p1.first)}, local_share2{uint32_t(p2.first)};
local_share2.sub(local_share2, local_share1);
b.mult(b, local_share2);
}
}
b.inv(b);
b.mult(a, b);
typename CryptoType::Signature t;
t.mult(p1.second, b);
res.add(res, t);
}
return res;
}
/**
* Generates the group public key, public key shares and private key share for a number of
* parties and a given signature threshold. Nodes must be allocated the outputs according
* to their index in the cabinet.
*
* @param committeeSize Number of parties for which private key shares are generated
* @param threshold Number of parties required to generate a group signature
* @return Vector of DkgOutputs containing the data to be given to each party
*/
static std::vector<DkgOutput> trustedDealer(uint32_t committeeSize, uint32_t threshold) {
std::vector<DkgOutput> output;
VerificationKey generator;
GroupPublicKey generator2;
setGenerator(generator);
setGenerator(generator2);
// Construct polynomial of degree threshold - 1
std::vector<PrivateKey> vec_a;
vec_a.resize(threshold);
for (uint32_t ii = 0; ii < threshold; ++ii) {
vec_a[ii].random();
}
std::vector<VerificationKey> publicKeyShares(committeeSize);
std::vector<PrivateKey> privateKeyShares(committeeSize);
// Group secret key is polynomial evaluated at 0
GroupPublicKey groupPublicKey;
PrivateKey group_private_key = vec_a[0];
groupPublicKey.mult(generator2, group_private_key);
// Generate committee public keys from their private key contributions
for (uint32_t i = 0; i < committeeSize; ++i) {
PrivateKey pow{i + 1}, tmpF, privateKey, cryptoRank{i + 1};
// Private key is polynomial evaluated at index i
privateKey = vec_a[0];
for (uint32_t k = 1; k < vec_a.size(); k++) {
tmpF.mult(pow, vec_a[k]);
privateKey.add(privateKey, tmpF);
pow.mult(pow, cryptoRank); // adjust index in computation
}
// Public key from private
VerificationKey publicKey;
publicKey.mult(generator, privateKey);
publicKeyShares[i] = publicKey;
privateKeyShares[i] = privateKey;
}
assert(publicKeyShares.size() == committeeSize);
assert(privateKeyShares.size() == committeeSize);
// Compute outputs for each member
for (uint32_t i = 0; i < committeeSize; ++i) {
output.emplace_back(groupPublicKey, publicKeyShares, privateKeyShares[i]);
}
return output;
}
protected:
const uint32_t committeeSize_; ///< Number of participants in DKG
uint32_t polynomialDegree_; ///< Degree of polynomial in DKG
GroupSignatureManager<BaseDkg> groupSignatureManager_;
VerificationKey G;
VerificationKey H;
/// Output of the DKG
/// @{
PrivateKey privateKey_;
GroupPublicKey groupPublicKey_;
std::vector<VerificationKey> publicKeyShares_;
/// @}
/// Temporary variables in DKG
/// @{
PrivateKey xprime_i_;
std::vector<std::vector<PrivateKey> > s_ij_, sprime_ij_;
std::vector<std::vector<VerificationKey>> C_ik_;
std::vector<std::vector<VerificationKey>> A_ik_;
std::vector<std::vector<VerificationKey>> g__s_ij_;
/// @}
std::unordered_map<std::string, std::pair<std::set<std::size_t>, std::vector<PrivateKey>>> reconstructionShares_;
///< Map from id of node_i in complaints to a pair <parties which
///< exposed shares of node_i, the shares that were exposed>
std::mutex mutex_;
virtual fetch::consensus::pb::Broadcast
createCoefficients(const std::vector<PrivateKey> &a_i, const std::vector<PrivateKey> &b_i, uint32_t rank) = 0;
template<typename T>
static void init(std::vector<std::vector<T>> &data, uint32_t i, uint32_t j) {
data.resize(i);
for (auto &data_i : data) {
data_i.resize(j);
}
}
std::vector<fetch::consensus::pb::PrivateShares>
createShares(const std::vector<PrivateKey> &a_i, const std::vector<PrivateKey> &b_i, uint32_t rank) {
std::vector<fetch::consensus::pb::PrivateShares> res;
for (size_t j = 0; j < committeeSize_; ++j) {
computeShares(s_ij_[rank][j], sprime_ij_[rank][j], a_i, b_i, j);
if (j != rank) {
PrivateShares shares{s_ij_[rank][j].toString(), sprime_ij_[rank][j].toString()};
res.emplace_back(shares.handle());
}
}
return res;
}
/**
* LHS and RHS functions are used for checking consistency between publicly broadcasted coefficients
* and secret shares distributed privately
*/
static VerificationKey
computeLHS(VerificationKey &tmpG, const VerificationKey &G,
const VerificationKey &H, const PrivateKey &share1,
const PrivateKey &share2) {
{
VerificationKey tmp2G, lhsG;
tmpG.mult(G, share1);
tmp2G.mult(H, share2);
lhsG.add(tmpG, tmp2G);
return lhsG;
}
}
static VerificationKey
computeLHS(const VerificationKey &G, const VerificationKey &H,
const PrivateKey &share1, const PrivateKey &share2) {
VerificationKey tmpG;
return computeLHS(tmpG, G, H, share1, share2);
}
static void updateRHS(size_t rank, VerificationKey &rhsG,
const std::vector<VerificationKey> &input) {
PrivateKey tmpF{uint32_t(rank + 1)}, cryptoRank{uint32_t(rank + 1)};
VerificationKey tmpG;
assert(input.size() > 0);
for (size_t k = 1; k < input.size(); k++) {
tmpG.mult(input[k], tmpF);
rhsG.add(rhsG, tmpG);
tmpF.mult(tmpF, cryptoRank); // adjust index $i$ in computation
}
}
static VerificationKey
computeRHS(size_t rank, const std::vector<VerificationKey> &input) {
VerificationKey rhsG{input[0]};
assert(input.size() > 0);
updateRHS(rank, rhsG, input);
return rhsG;
}
/**
* Given two polynomials (f and f') with coefficients a_i and b_i, we compute the evaluation of
* these polynomials at different points
*
* @param s_i The value of f(rank)
* @param sprime_i The value of f'(rank)
* @param a_i The vector of coefficients for f
* @param b_i The vector of coefficients for f'
* @param rank The point at which you evaluate the polynomial
*/
static void
computeShares(PrivateKey &s_i, PrivateKey &sprime_i,
const std::vector<PrivateKey> &a_i,
const std::vector<PrivateKey> &b_i,
size_t rank) {
PrivateKey pow{uint32_t(rank + 1)}, tmpF, cryptoRank{uint32_t(rank + 1)};
assert(a_i.size() == b_i.size());
assert(a_i.size() > 0);
s_i = a_i[0];
sprime_i = b_i[0];
for (size_t k = 1; k < a_i.size(); k++) {
tmpF.mult(pow, b_i[k]);
sprime_i.add(sprime_i, tmpF);
tmpF.mult(pow, a_i[k]);
s_i.add(s_i, tmpF);
pow.mult(pow, cryptoRank); // adjust index $j$ in computation
}
}
/**
* Computes the coefficients of a polynomial
*
* @param a Points at which polynomial has been evaluated
* @param b Value of the polynomial at points a
* @return The vector of coefficients of the polynomial
*/
static std::vector<PrivateKey>
interpolatePolynom(const std::vector<PrivateKey> &a,
const std::vector<PrivateKey> &b) {
size_t m = a.size();
if ((b.size() != m) || (m == 0))
throw std::invalid_argument("mcl_interpolate_polynom: bad m");
std::vector<PrivateKey> prod{a}, res(m);
for (size_t k = 0; k < m; k++) {
PrivateKey t1{1};
for (long i = k - 1; i >= 0; i--) {
t1.mult(t1, a[k]);
t1.add(t1, prod[i]);
}
PrivateKey t2;
for (long i = k - 1; i >= 0; i--) {
t2.mult(t2, a[k]);
t2.add(t2, res[i]);
}
t2.sub(b[k], t2);
t1.div(t2, t1);
for (size_t i = 0; i < k; i++) {
t2.mult(prod[i], t1);
res[i].add(res[i], t2);
}
res[k] = t1;
if (k < (m - 1)) {
if (k == 0)
prod[0].negate(prod[0]);
else {
t1.negate(a[k]);
prod[k].add(t1, prod[k - 1]);
for (long i = k - 1; i >= 1; i--) {
t2.mult(prod[i], t1);
prod[i].add(t2, prod[i - 1]);
}
prod[0].mult(prod[0], t1);
}
}
}
return res;
}
};
}
} | 34.473258 | 120 | 0.658063 | fetchai |
b4b01ddff1189da2fcffbeb47138f9644b0fb89c | 1,009 | cpp | C++ | waterbox/bsnescore/bsnes/sfc/coprocessor/sa1/iram.cpp | Fortranm/BizHawk | 8cb0ffb6f8964cc339bbe1784838918fb0aa7e27 | [
"MIT"
] | 1,414 | 2015-06-28T09:57:51.000Z | 2021-10-14T03:51:10.000Z | waterbox/bsnescore/bsnes/sfc/coprocessor/sa1/iram.cpp | Fortranm/BizHawk | 8cb0ffb6f8964cc339bbe1784838918fb0aa7e27 | [
"MIT"
] | 2,369 | 2015-06-25T01:45:44.000Z | 2021-10-16T08:44:18.000Z | waterbox/bsnescore/bsnes/sfc/coprocessor/sa1/iram.cpp | Fortranm/BizHawk | 8cb0ffb6f8964cc339bbe1784838918fb0aa7e27 | [
"MIT"
] | 430 | 2015-06-29T04:28:58.000Z | 2021-10-05T18:24:17.000Z | auto SA1::IRAM::conflict() const -> bool {
if(configuration.hacks.coprocessor.delayedSync) return false;
if((cpu.r.mar & 0x40f800) == 0x003000) return cpu.refresh() == 0; //00-3f,80-bf:3000-37ff
return false;
}
auto SA1::IRAM::read(uint address, uint8 data) -> uint8 {
if(!size()) return data;
address = bus.mirror(address, size());
return WritableMemory::read(address, data);
}
auto SA1::IRAM::write(uint address, uint8 data) -> void {
if(!size()) return;
address = bus.mirror(address, size());
return WritableMemory::write(address, data);
}
auto SA1::IRAM::readCPU(uint address, uint8 data) -> uint8 {
cpu.synchronizeCoprocessors();
return read(address, data);
}
auto SA1::IRAM::writeCPU(uint address, uint8 data) -> void {
cpu.synchronizeCoprocessors();
return write(address, data);
}
auto SA1::IRAM::readSA1(uint address, uint8 data) -> uint8 {
return read(address, data);
}
auto SA1::IRAM::writeSA1(uint address, uint8 data) -> void {
return write(address, data);
}
| 27.27027 | 92 | 0.686819 | Fortranm |
b4b04407fd4a536b00436666f0ba5fe5c63361b9 | 909 | cpp | C++ | venv/lib/python3.7/site-packages/pystan/stan/lib/stan_math/test/unit/math/prim/scal/fun/promote_elements_test.cpp | vchiapaikeo/prophet | e8c250ca7bfffc280baa7dabc80a2c2d1f72c6a7 | [
"MIT"
] | 1 | 2019-09-06T15:53:17.000Z | 2019-09-06T15:53:17.000Z | venv/lib/python3.7/site-packages/pystan/stan/lib/stan_math/test/unit/math/prim/scal/fun/promote_elements_test.cpp | vchiapaikeo/prophet | e8c250ca7bfffc280baa7dabc80a2c2d1f72c6a7 | [
"MIT"
] | 8 | 2019-01-17T18:51:16.000Z | 2019-01-17T18:51:39.000Z | test/unit/math/prim/scal/fun/promote_elements_test.cpp | riddell-stan/math | d84ee0d991400d6cf4b08a07a4e8d86e0651baea | [
"BSD-3-Clause"
] | null | null | null | #include <stan/math/prim/scal.hpp>
#include <stan/math/rev/core/var.hpp>
#include <gtest/gtest.h>
#include <boost/typeof/typeof.hpp>
#include <type_traits>
using stan::math::promote_elements;
using stan::math::var;
TEST(MathFunctionsScalPromote_Elements, int2double) {
int from;
promote_elements<double, int> p;
typedef BOOST_TYPEOF(p.promote(from)) result_t;
bool same = std::is_same<double, result_t>::value;
EXPECT_TRUE(same);
}
TEST(MathFunctionsScalPromote_Elements, double2double) {
double from;
promote_elements<double, double> p;
typedef BOOST_TYPEOF(p.promote(from)) result_t;
bool same = std::is_same<double, result_t>::value;
EXPECT_TRUE(same);
}
TEST(MathFunctionsScalPromote_Elements, double2var) {
double from;
promote_elements<var, double> p;
typedef BOOST_TYPEOF(p.promote(from)) result_t;
bool same = std::is_same<var, result_t>::value;
EXPECT_TRUE(same);
}
| 27.545455 | 56 | 0.752475 | vchiapaikeo |
b4b0744abd82d7c910b256ca203276348aed6a49 | 4,101 | hpp | C++ | ext/src/java/lang/Integer.hpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | ext/src/java/lang/Integer.hpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | ext/src/java/lang/Integer.hpp | pebble2015/cpoi | 6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6 | [
"Apache-2.0"
] | null | null | null | // Generated from /Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home/jre/lib/rt.jar
#pragma once
#include <fwd-POI.hpp>
#include <java/lang/fwd-POI.hpp>
#include <java/lang/Number.hpp>
#include <java/lang/Comparable.hpp>
struct default_init_tag;
class java::lang::Integer final
: public Number
, public Comparable
{
public:
typedef Number super;
static constexpr int32_t BYTES { int32_t(4) };
private:
static ::char16_tArray* DigitOnes_;
static ::char16_tArray* DigitTens_;
public:
static constexpr int32_t MAX_VALUE { int32_t(2147483647) };
static constexpr int32_t MIN_VALUE { int32_t(-0x7fffffff-1) };
static constexpr int32_t SIZE { int32_t(32) };
private:
static Class* TYPE_;
static ::char16_tArray* digits_;
static constexpr int64_t serialVersionUID { int64_t(1360826667806852920LL) };
static ::int32_tArray* sizeTable_;
int32_t value { };
protected:
void ctor(int32_t value);
void ctor(String* s);
public:
static int32_t bitCount(int32_t i);
int8_t byteValue() override;
static int32_t compare(int32_t x, int32_t y);
int32_t compareTo(Integer* anotherInteger);
static int32_t compareUnsigned(int32_t x, int32_t y);
static Integer* decode(String* nm);
static int32_t divideUnsigned(int32_t dividend, int32_t divisor);
double doubleValue() override;
bool equals(Object* obj) override;
float floatValue() override;
public: /* package */
static int32_t formatUnsignedInt(int32_t val, int32_t shift, ::char16_tArray* buf, int32_t offset, int32_t len);
static void getChars(int32_t i, int32_t index, ::char16_tArray* buf);
public:
static Integer* getInteger(String* nm);
static Integer* getInteger(String* nm, int32_t val);
static Integer* getInteger(String* nm, Integer* val);
int32_t hashCode() override;
static int32_t hashCode(int32_t value);
static int32_t highestOneBit(int32_t i);
int32_t intValue() override;
int64_t longValue() override;
static int32_t lowestOneBit(int32_t i);
static int32_t max(int32_t a, int32_t b);
static int32_t min(int32_t a, int32_t b);
static int32_t numberOfLeadingZeros(int32_t i);
static int32_t numberOfTrailingZeros(int32_t i);
static int32_t parseInt(String* s);
static int32_t parseInt(String* s, int32_t radix);
static int32_t parseUnsignedInt(String* s);
static int32_t parseUnsignedInt(String* s, int32_t radix);
static int32_t remainderUnsigned(int32_t dividend, int32_t divisor);
static int32_t reverse(int32_t i);
static int32_t reverseBytes(int32_t i);
static int32_t rotateLeft(int32_t i, int32_t distance);
static int32_t rotateRight(int32_t i, int32_t distance);
int16_t shortValue() override;
static int32_t signum(int32_t i);
public: /* package */
static int32_t stringSize(int32_t x);
public:
static int32_t sum(int32_t a, int32_t b);
static String* toBinaryString(int32_t i);
static String* toHexString(int32_t i);
static String* toOctalString(int32_t i);
String* toString() override;
static String* toString(int32_t i);
static String* toString(int32_t i, int32_t radix);
static int64_t toUnsignedLong(int32_t x);
static String* toUnsignedString(int32_t i);
static String* toUnsignedString(int32_t i, int32_t radix);
/*static String* toUnsignedString0(int32_t val, int32_t shift); (private) */
static Integer* valueOf(String* s);
static Integer* valueOf(int32_t i);
static Integer* valueOf(String* s, int32_t radix);
// Generated
Integer(int32_t value);
Integer(String* s);
protected:
Integer(const ::default_init_tag&);
public:
static ::java::lang::Class *class_();
virtual int32_t compareTo(Object* o) override;
public: /* package */
static ::char16_tArray*& DigitOnes();
static ::char16_tArray*& DigitTens();
public:
static Class*& TYPE();
public: /* package */
static ::char16_tArray*& digits();
static ::int32_tArray*& sizeTable();
private:
virtual ::java::lang::Class* getClass0();
};
| 32.291339 | 116 | 0.717142 | pebble2015 |
b4b4b7612769a8959e9781c826428e3fcfdb3b7b | 4,441 | cpp | C++ | tinysdl/Game/Tetris/App.cpp | silent1603/silent1603-TinySDL | 7b3470b2e343bcec8d4788de2d817b41bec1141d | [
"MIT"
] | null | null | null | tinysdl/Game/Tetris/App.cpp | silent1603/silent1603-TinySDL | 7b3470b2e343bcec8d4788de2d817b41bec1141d | [
"MIT"
] | null | null | null | tinysdl/Game/Tetris/App.cpp | silent1603/silent1603-TinySDL | 7b3470b2e343bcec8d4788de2d817b41bec1141d | [
"MIT"
] | null | null | null | #include "App.hpp"
namespace Tetris
{
#define MIN_SIZE_WIDTH 600
#define MIN_SIZE_HEIGHT 400
App::App(/* args */) : m_strTitle("Tetris"),
m_iWidth(800),
m_iHeight(600)
{
}
App::~App()
{
}
App::App(std::string title, int width, int height) : m_strTitle(title),
m_iWidth(width),
m_iHeight(height)
{
}
bool App::init()
{
// initiate SDL
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
TETRIS_ERROR("SDL init failed");
return false;
}
// set OpenGL attributes
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
// set profile contetnt for opengl
SDL_GL_SetAttribute(
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_CORE);
std::string glsl_version = "#version 330";
#ifdef __APPLE__
// GL 4.1 Core + GLSL 410
glsl_version = "#version 410";
SDL_GL_SetAttribute( // required on Mac OS
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
#elif __linux__
// GL 4.3 Core + GLSL 430
glsl_version = "#version 430";
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#elif _WIN32
// GL 3.3 + GLSL 330
glsl_version = "#version 330";
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#endif
SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
m_sdl2Window = SDL_CreateWindow(
m_strTitle.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
m_iWidth,
m_iHeight,
window_flags);
SDL_SetWindowMinimumSize(m_sdl2Window, MIN_SIZE_WIDTH, MIN_SIZE_HEIGHT);
m_glContext = SDL_GL_CreateContext(m_sdl2Window);
if (m_glContext == nullptr)
{
TETRIS_ERROR("Can't init GLContent");
}
SDL_GL_MakeCurrent(m_sdl2Window, m_glContext);
// enable VSync
SDL_GL_SetSwapInterval(1);
if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress))
{
TETRIS_ERROR("Couldn't initialize glad");
return false;
}
glViewport(0, 0, m_iWidth, m_iHeight);
glClearColor(0.0f, 0.0f,0.0f, 0.0f);
return true;
}
void App::update()
{
m_isRunning = true;
SDL_Event e;
while (m_isRunning)
{
while (SDL_PollEvent(&e))
{
if (e.type == SDL_QUIT)
{
m_isRunning = false;
}
else {
switch (e.key.keysym.sym)
{
case SDLK_ESCAPE:
m_isRunning = false;
break;
default:
break;
}
}
if (e.type == SDL_WINDOWEVENT)
{
switch (e.window.event)
{
case SDL_WINDOWEVENT_RESIZED:
m_iWidth = e.window.data1;
m_iHeight = e.window.data2;
TETRIS_INFO( m_iWidth);
TETRIS_INFO( m_iHeight);
SDL_SetWindowSize(m_sdl2Window, m_iWidth, m_iHeight);
break;
default:
break;
}
}
}
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
SDL_GL_SwapWindow(m_sdl2Window);
}
}
void App::clean()
{
SDL_GL_DeleteContext(m_glContext);
SDL_DestroyWindow(m_sdl2Window);
SDL_Quit();
}
} | 28.467949 | 126 | 0.517901 | silent1603 |
b4b5b33df2ac6538dd6be817ea7bb9e279244b1a | 178 | cpp | C++ | Iniciante/1008.cpp | nobreconfrade/AKIRA | 6040f6db0efe3a4c9ca7fe360859bf3f3ca58e42 | [
"Apache-2.0"
] | null | null | null | Iniciante/1008.cpp | nobreconfrade/AKIRA | 6040f6db0efe3a4c9ca7fe360859bf3f3ca58e42 | [
"Apache-2.0"
] | null | null | null | Iniciante/1008.cpp | nobreconfrade/AKIRA | 6040f6db0efe3a4c9ca7fe360859bf3f3ca58e42 | [
"Apache-2.0"
] | null | null | null | #include <iostream>
#include <stdio.h>
using namespace std;
int main(){
float a,b,c;
cin>>a>>b>>c;
printf("NUMBER = %.0f\n",a);
printf("SALARY = U$ %.2f\n",b*c);
return 0;
} | 17.8 | 34 | 0.601124 | nobreconfrade |
b4bab8beddc277e7ec1c0d68931e5cb56e009338 | 6,914 | hpp | C++ | dependencies/osi_clp/Clp/src/ClpDynamicExampleMatrix.hpp | zyxrrr/GraphSfM | 1af22ec17950ffc8a5c737a6a46f4465c40aa470 | [
"BSD-3-Clause"
] | 5 | 2020-01-28T08:38:35.000Z | 2021-06-19T04:11:23.000Z | dependencies/osi_clp/Clp/src/ClpDynamicExampleMatrix.hpp | zyxrrr/GraphSfM | 1af22ec17950ffc8a5c737a6a46f4465c40aa470 | [
"BSD-3-Clause"
] | null | null | null | dependencies/osi_clp/Clp/src/ClpDynamicExampleMatrix.hpp | zyxrrr/GraphSfM | 1af22ec17950ffc8a5c737a6a46f4465c40aa470 | [
"BSD-3-Clause"
] | 3 | 2019-11-26T14:43:13.000Z | 2021-10-06T08:03:46.000Z | /* $Id$ */
// Copyright (C) 2004, International Business Machines
// Corporation and others. All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
#ifndef ClpDynamicExampleMatrix_H
#define ClpDynamicExampleMatrix_H
#include "CoinPragma.hpp"
#include "ClpDynamicMatrix.hpp"
class ClpSimplex;
/** This implements a dynamic matrix when we have a limit on the number of
"interesting rows". This version inherits from ClpDynamicMatrix and knows that
the real matrix is gub. This acts just like ClpDynamicMatrix but generates columns.
This "generates" columns by choosing from stored set. It is maent as a starting point
as to how you could use shortest path to generate columns.
So it has its own copy of all data needed. It populates ClpDynamicWatrix with enough
to allow for gub keys and active variables. In turn ClpDynamicMatrix populates
a CoinPackedMatrix with active columns and rows.
As there is one copy here and one in ClpDynamicmatrix these names end in Gen_
It is obviously more efficient to just use ClpDynamicMatrix but the ideas is to
show how much code a user would have to write.
This does not work very well with bounds
*/
class ClpDynamicExampleMatrix : public ClpDynamicMatrix {
public:
/**@name Main functions provided */
//@{
/// Partial pricing
virtual void partialPricing(ClpSimplex * model, double start, double end,
int & bestSequence, int & numberWanted);
/** Creates a variable. This is called after partial pricing and will modify matrix.
Will update bestSequence.
*/
virtual void createVariable(ClpSimplex * model, int & bestSequence);
/** If addColumn forces compression then this allows descendant to know what to do.
If >= then entry stayed in, if -1 then entry went out to lower bound.of zero.
Entries at upper bound (really nonzero) never go out (at present).
*/
virtual void packDown(const int * in, int numberToPack);
//@}
/**@name Constructors, destructor */
//@{
/** Default constructor. */
ClpDynamicExampleMatrix();
/** This is the real constructor.
It assumes factorization frequency will not be changed.
This resizes model !!!!
The contents of original matrix in model will be taken over and original matrix
will be sanitized so can be deleted (to avoid a very small memory leak)
*/
ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
int numberColumns, const int * starts,
const double * lower, const double * upper,
const int * startColumn, const int * row,
const double * element, const double * cost,
const double * columnLower = NULL, const double * columnUpper = NULL,
const unsigned char * status = NULL,
const unsigned char * dynamicStatus = NULL,
int numberIds = 0, const int *ids = NULL);
#if 0
/// This constructor just takes over ownership (except for lower, upper)
ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
int numberColumns, int * starts,
const double * lower, const double * upper,
int * startColumn, int * row,
double * element, double * cost,
double * columnLower = NULL, double * columnUpper = NULL,
const unsigned char * status = NULL,
const unsigned char * dynamicStatus = NULL,
int numberIds = 0, const int *ids = NULL);
#endif
/** Destructor */
virtual ~ClpDynamicExampleMatrix();
//@}
/**@name Copy method */
//@{
/** The copy constructor. */
ClpDynamicExampleMatrix(const ClpDynamicExampleMatrix&);
ClpDynamicExampleMatrix& operator=(const ClpDynamicExampleMatrix&);
/// Clone
virtual ClpMatrixBase * clone() const ;
//@}
/**@name gets and sets */
//@{
/// Starts of each column
inline CoinBigIndex * startColumnGen() const {
return startColumnGen_;
}
/// rows
inline int * rowGen() const {
return rowGen_;
}
/// elements
inline double * elementGen() const {
return elementGen_;
}
/// costs
inline double * costGen() const {
return costGen_;
}
/// full starts
inline int * fullStartGen() const {
return fullStartGen_;
}
/// ids in next level matrix
inline int * idGen() const {
return idGen_;
}
/// Optional lower bounds on columns
inline double * columnLowerGen() const {
return columnLowerGen_;
}
/// Optional upper bounds on columns
inline double * columnUpperGen() const {
return columnUpperGen_;
}
/// size
inline int numberColumns() const {
return numberColumns_;
}
inline void setDynamicStatusGen(int sequence, DynamicStatus status) {
unsigned char & st_byte = dynamicStatusGen_[sequence];
st_byte = static_cast<unsigned char>(st_byte & ~7);
st_byte = static_cast<unsigned char>(st_byte | status);
}
inline DynamicStatus getDynamicStatusGen(int sequence) const {
return static_cast<DynamicStatus> (dynamicStatusGen_[sequence] & 7);
}
/// Whether flagged
inline bool flaggedGen(int i) const {
return (dynamicStatusGen_[i] & 8) != 0;
}
inline void setFlaggedGen(int i) {
dynamicStatusGen_[i] = static_cast<unsigned char>(dynamicStatusGen_[i] | 8);
}
inline void unsetFlagged(int i) {
dynamicStatusGen_[i] = static_cast<unsigned char>(dynamicStatusGen_[i] & ~8);
}
//@}
protected:
/**@name Data members
The data members are protected to allow access for derived classes. */
//@{
/// size
int numberColumns_;
/// Starts of each column
CoinBigIndex * startColumnGen_;
/// rows
int * rowGen_;
/// elements
double * elementGen_;
/// costs
double * costGen_;
/// start of each set
int * fullStartGen_;
/// for status and which bound
unsigned char * dynamicStatusGen_;
/** identifier for each variable up one level (startColumn_, etc). This is
of length maximumGubColumns_. For this version it is just sequence number
at this level */
int * idGen_;
/// Optional lower bounds on columns
double * columnLowerGen_;
/// Optional upper bounds on columns
double * columnUpperGen_;
//@}
};
#endif
| 36.973262 | 98 | 0.614406 | zyxrrr |
b4bba29492d76f324d1eb8dc7a2a3a6d3362e579 | 8,093 | cpp | C++ | ShaderParser/NodeGraph.cpp | pocketgems/XLE2 | 82771e9ab1fc3b12927f1687bbe05d4f7dce8765 | [
"MIT"
] | 3 | 2018-05-17T08:39:39.000Z | 2020-12-09T13:20:26.000Z | ShaderParser/NodeGraph.cpp | djewsbury/XLE | 7806e4b5c9de5631c94c2020f6adcd4bd8e3d91e | [
"MIT"
] | null | null | null | ShaderParser/NodeGraph.cpp | djewsbury/XLE | 7806e4b5c9de5631c94c2020f6adcd4bd8e3d91e | [
"MIT"
] | 2 | 2015-03-03T05:32:39.000Z | 2015-12-04T09:16:54.000Z | // Distributed under the MIT License (See
// accompanying file "LICENSE" or the website
// http://www.opensource.org/licenses/mit-license.php)
#include "NodeGraph.h"
namespace GraphLanguage
{
const std::string s_resultName = "result";
const std::string ParameterName_NodeInstantiation = "<instantiation>";
NodeGraph::NodeGraph() {}
NodeGraph::~NodeGraph() {}
void NodeGraph::Add(Node&& a) { _nodes.emplace_back(std::move(a)); }
void NodeGraph::Add(Connection&& a) { _connections.emplace_back(std::move(a)); }
bool NodeGraph::IsUpstream(NodeId startNode, NodeId searchingForNode)
{
// Starting at 'startNode', search upstream and see if we find 'searchingForNode'
if (startNode == searchingForNode) {
return true;
}
for (auto i=_connections.cbegin(); i!=_connections.cend(); ++i) {
if (i->OutputNodeId() == startNode) {
auto inputNode = i->InputNodeId();
if (inputNode != NodeId_Interface && inputNode != NodeId_Constant && IsUpstream(i->InputNodeId(), searchingForNode)) {
return true;
}
}
}
return false;
}
bool NodeGraph::IsDownstream(
NodeId startNode,
const NodeId* searchingForNodesStart, const NodeId* searchingForNodesEnd)
{
if (std::find(searchingForNodesStart, searchingForNodesEnd, startNode) != searchingForNodesEnd) {
return true;
}
for (auto i=_connections.cbegin(); i!=_connections.cend(); ++i) {
if (i->InputNodeId() == startNode) {
auto outputNode = i->OutputNodeId();
if (outputNode != NodeId_Interface && outputNode != NodeId_Constant && IsDownstream(outputNode, searchingForNodesStart, searchingForNodesEnd)) {
return true;
}
}
}
return false;
}
bool NodeGraph::HasNode(NodeId nodeId)
{
// Special case node ids are considered to always exist (particularly required when called from Trim())
if (nodeId == NodeId_Interface || nodeId == NodeId_Constant) return true;
return std::find_if(_nodes.begin(), _nodes.end(),
[=](const Node& node) { return node.NodeId() == nodeId; }) != _nodes.end();
}
const Node* NodeGraph::GetNode(NodeId nodeId) const
{
auto res = std::find_if(
_nodes.cbegin(), _nodes.cend(),
[=](const Node& n) { return n.NodeId() == nodeId; });
if (res != _nodes.cend()) {
return &*res;
}
return nullptr;
}
void NodeGraph::Trim(NodeId previewNode)
{
Trim(&previewNode, &previewNode+1);
}
void NodeGraph::Trim(const NodeId* trimNodesBegin, const NodeId* trimNodesEnd)
{
//
// Trim out all of the nodes that are upstream of
// 'previewNode' (except for output nodes that are
// directly written by one of the trim nodes)
//
// Simply
// 1. remove all nodes, unless they are downstream
// of 'previewNode'
// 2. remove all connections that refer to nodes
// that no longer exist
//
// Generally, there won't be an output connection attached
// to the previewNode at the end of the process. So, we
// may need to create one.
//
_nodes.erase(
std::remove_if(
_nodes.begin(), _nodes.end(),
[=](const Node& node) { return !IsDownstream(node.NodeId(), trimNodesBegin, trimNodesEnd); }),
_nodes.end());
_connections.erase(
std::remove_if(
_connections.begin(), _connections.end(),
[=](const Connection& connection)
{ return !HasNode(connection.InputNodeId()) || !HasNode(connection.OutputNodeId()) || connection.OutputNodeId() == NodeId_Interface; }),
_connections.end());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
static void OrderNodes(IteratorRange<NodeId*> range)
{
// We need to sort the upstreams in some way that maintains a
// consistant ordering. The simplied way is just to use node id.
// However we may sometimes want to set priorities for nodes.
// For example, nodes that can "discard" pixels should be priortized
// higher.
std::sort(range.begin(), range.end());
}
static bool SortNodesFunction(
NodeId node,
std::vector<NodeId>& presorted,
std::vector<NodeId>& sorted,
std::vector<NodeId>& marks,
const NodeGraph& graph)
{
if (std::find(presorted.begin(), presorted.end(), node) == presorted.end()) {
return false; // hit a cycle
}
if (std::find(marks.begin(), marks.end(), node) != marks.end()) {
return false; // hit a cycle
}
marks.push_back(node);
std::vector<NodeId> upstream;
upstream.reserve(graph.GetConnections().size());
for (const auto& i:graph.GetConnections())
if (i.OutputNodeId() == node)
upstream.push_back(i.InputNodeId());
OrderNodes(MakeIteratorRange(upstream));
for (const auto& i2:upstream)
SortNodesFunction(i2, presorted, sorted, marks, graph);
sorted.push_back(node);
presorted.erase(std::find(presorted.begin(), presorted.end(), node));
return true;
}
std::vector<NodeId> SortNodes(const NodeGraph& graph, bool& isAcyclic)
{
/*
We need to create a directed acyclic graph from the nodes in 'graph'
-- and then we need to do a topological sort.
This will tell us the order in which to call each function
Basic algorithms:
L <- Empty list that will contain the sorted elements
S <- Set of all nodes with no incoming edges
while S is non-empty do
remove a node n from S
add n to tail of L
for each node m with an edge e from n to m do
remove edge e from the graph
if m has no other incoming edges then
insert m into S
if graph has edges then
return error (graph has at least one cycle)
else
return L (a topologically sorted order)
Depth first sort:
L <- Empty list that will contain the sorted nodes
while there are unmarked nodes do
select an unmarked node n
visit(n)
function visit(node n)
if n has a temporary mark then stop (not a DAG)
if n is not marked (i.e. has not been visited yet) then
mark n temporarily
for each node m with an edge from n to m do
visit(m)
mark n permanently
add n to head of L
*/
std::vector<NodeId> presortedNodes, sortedNodes;
sortedNodes.reserve(graph.GetNodes().size());
for (const auto& i:graph.GetNodes())
presortedNodes.push_back(i.NodeId());
OrderNodes(MakeIteratorRange(presortedNodes));
isAcyclic = true;
while (!presortedNodes.empty()) {
std::vector<NodeId> temporaryMarks;
bool sortReturn = SortNodesFunction(
presortedNodes[0],
presortedNodes, sortedNodes,
temporaryMarks, graph);
if (!sortReturn) {
isAcyclic = false;
break;
}
}
return sortedNodes;
}
}
| 35.968889 | 160 | 0.540344 | pocketgems |
b4bc34420daa43633be23c1cc9e20ad6852e3bfe | 496 | cpp | C++ | Contest 1006/D.cpp | PC-DOS/SEUCPP-OJ-KEYS | 073f97fb29a659abd25554330382f0a7149c2511 | [
"MIT"
] | null | null | null | Contest 1006/D.cpp | PC-DOS/SEUCPP-OJ-KEYS | 073f97fb29a659abd25554330382f0a7149c2511 | [
"MIT"
] | null | null | null | Contest 1006/D.cpp | PC-DOS/SEUCPP-OJ-KEYS | 073f97fb29a659abd25554330382f0a7149c2511 | [
"MIT"
] | null | null | null | #include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;
int main() {
unsigned long orig,i,j,tmp;
cin >> orig;
tmp = orig;
if (orig == 1){
cout << "1=1"<<endl;
goto endapp;
}
cout << orig << '=';
for (i = 2; tmp != 1 && i<=orig; ++i){
while (tmp%i == 0){
cout << i;
tmp /= i;
if (tmp != 1) cout << '*';
}
}
cout << endl;
//system("pause>nul");
endapp:
return 0;
} | 19.84 | 42 | 0.431452 | PC-DOS |
b4bdef12b202efb72b46b38e20fb24e47b565294 | 11,416 | cpp | C++ | Server/src/modules/SD3/scripts/eastern_kingdoms/zulgurub/instance_zulgurub.cpp | ZON3DEV/wow-vanilla | 7b6f03c3e1e7d8dd29a92ba77ed021e5913e5e9f | [
"OpenSSL"
] | null | null | null | Server/src/modules/SD3/scripts/eastern_kingdoms/zulgurub/instance_zulgurub.cpp | ZON3DEV/wow-vanilla | 7b6f03c3e1e7d8dd29a92ba77ed021e5913e5e9f | [
"OpenSSL"
] | null | null | null | Server/src/modules/SD3/scripts/eastern_kingdoms/zulgurub/instance_zulgurub.cpp | ZON3DEV/wow-vanilla | 7b6f03c3e1e7d8dd29a92ba77ed021e5913e5e9f | [
"OpenSSL"
] | null | null | null | /**
* ScriptDev3 is an extension for mangos providing enhanced features for
* area triggers, creatures, game objects, instances, items, and spells beyond
* the default database scripting in mangos.
*
* Copyright (C) 2006-2013 ScriptDev2 <http://www.scriptdev2.com/>
* Copyright (C) 2014-2022 MaNGOS <https://getmangos.eu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* World of Warcraft, and all World of Warcraft or Warcraft art, images,
* and lore are copyrighted by Blizzard Entertainment, Inc.
*/
/**
* ScriptData
* SDName: Instance_ZulGurub
* SD%Complete: 80
* SDComment: Missing reset function after killing a boss for Ohgan, Thekal.
* SDCategory: Zul'Gurub
* EndScriptData
*/
#include "precompiled.h"
#include "zulgurub.h"
struct is_zulgurub : public InstanceScript
{
is_zulgurub() : InstanceScript("instance_zulgurub") {}
class instance_zulgurub : public ScriptedInstance
{
public:
instance_zulgurub(Map* pMap) : ScriptedInstance(pMap),
m_bHasIntroYelled(false),
m_bHasAltarYelled(false)
{
Initialize();
}
~instance_zulgurub() {}
void Initialize() override
{
memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
}
// IsEncounterInProgress() const override { return false; } // not active in Zul'Gurub
void OnCreatureCreate(Creature* pCreature) override
{
switch (pCreature->GetEntry())
{
case NPC_LORKHAN:
case NPC_ZATH:
case NPC_THEKAL:
case NPC_JINDO:
case NPC_HAKKAR:
case NPC_BLOODLORD_MANDOKIR:
case NPC_MARLI:
m_mNpcEntryGuidStore[pCreature->GetEntry()] = pCreature->GetObjectGuid();
break;
case NPC_PANTHER_TRIGGER:
if (pCreature->GetPositionY() < -1626)
{
m_lLeftPantherTriggerGUIDList.push_back(pCreature->GetObjectGuid());
}
else
{
m_lRightPantherTriggerGUIDList.push_back(pCreature->GetObjectGuid());
}
break;
}
}
void OnObjectCreate(GameObject* pGo) override
{
switch (pGo->GetEntry())
{
case GO_GONG_OF_BETHEKK:
case GO_FORCEFIELD:
break;
case GO_SPIDER_EGG:
m_lSpiderEggGUIDList.push_back(pGo->GetObjectGuid());
return;
}
m_mGoEntryGuidStore[pGo->GetEntry()] = pGo->GetObjectGuid();
}
void SetData(uint32 uiType, uint32 uiData) override
{
switch (uiType)
{
case TYPE_JEKLIK:
case TYPE_VENOXIS:
case TYPE_THEKAL:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
DoLowerHakkarHitPoints();
}
break;
case TYPE_MARLI:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
DoLowerHakkarHitPoints();
}
if (uiData == FAIL)
{
for (GuidList::const_iterator itr = m_lSpiderEggGUIDList.begin(); itr != m_lSpiderEggGUIDList.end(); ++itr)
{
if (GameObject* pEgg = instance->GetGameObject(*itr))
{
// Note: this type of Gameobject needs to be respawned manually
pEgg->SetRespawnTime(2 * DAY);
pEgg->Respawn();
}
}
}
break;
case TYPE_ARLOKK:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_FORCEFIELD);
if (uiData == DONE)
{
DoLowerHakkarHitPoints();
}
if (uiData == FAIL)
{
// Note: this gameobject should change flags - currently it despawns which isn't correct
if (GameObject* pGong = GetSingleGameObjectFromStorage(GO_GONG_OF_BETHEKK))
{
pGong->SetRespawnTime(2 * DAY);
pGong->Respawn();
}
}
break;
case TYPE_OHGAN:
// Note: SPECIAL instance data is set via ACID!
if (uiData == SPECIAL)
{
if (Creature* pMandokir = GetSingleCreatureFromStorage(NPC_BLOODLORD_MANDOKIR))
{
pMandokir->SetWalk(false);
pMandokir->GetMotionMaster()->MovePoint(1, aMandokirDownstairsPos[0], aMandokirDownstairsPos[1], aMandokirDownstairsPos[2]);
}
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_LORKHAN:
case TYPE_ZATH:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_SIGNAL_1:
DoYellAtTriggerIfCan(uiData);
return;
}
if (uiData == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2] << " "
<< m_auiEncounter[3] << " " << m_auiEncounter[4] << " " << m_auiEncounter[5] << " "
<< m_auiEncounter[6] << " " << m_auiEncounter[7];
m_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
uint32 GetData(uint32 uiType) const override
{
if (uiType < MAX_ENCOUNTER)
{
return m_auiEncounter[uiType];
}
return 0;
}
uint64 GetData64(uint32 type) const override
{
switch (type)
{
case TYPE_SIGNAL_2:
case TYPE_SIGNAL_3:
if (Creature *p = (const_cast<instance_zulgurub*>(this))->SelectRandomPantherTrigger(type == TYPE_SIGNAL_2))
{
return p->GetObjectGuid().GetRawValue();
}
break;
default:
break;
}
return 0;
}
const char* Save() const override { return m_strInstData.c_str(); }
void Load(const char* chrIn) override
{
if (!chrIn)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(chrIn);
std::istringstream loadStream(chrIn);
loadStream >> m_auiEncounter[0] >> m_auiEncounter[1] >> m_auiEncounter[2] >> m_auiEncounter[3]
>> m_auiEncounter[4] >> m_auiEncounter[5] >> m_auiEncounter[6] >> m_auiEncounter[7];
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
{
if (m_auiEncounter[i] == IN_PROGRESS)
{
m_auiEncounter[i] = NOT_STARTED;
}
}
OUT_LOAD_INST_DATA_COMPLETE;
}
private:
void DoLowerHakkarHitPoints()
{
if (Creature* pHakkar = GetSingleCreatureFromStorage(NPC_HAKKAR))
{
if (pHakkar->IsAlive() && pHakkar->GetMaxHealth() > HP_LOSS_PER_PRIEST)
{
pHakkar->SetMaxHealth(pHakkar->GetMaxHealth() - HP_LOSS_PER_PRIEST);
pHakkar->SetHealth(pHakkar->GetHealth() - HP_LOSS_PER_PRIEST);
}
}
}
void DoYellAtTriggerIfCan(uint32 uiTriggerId)
{
if (uiTriggerId == AREATRIGGER_ENTER && !m_bHasIntroYelled)
{
DoOrSimulateScriptTextForThisInstance(SAY_HAKKAR_PROTECT, NPC_HAKKAR);
m_bHasIntroYelled = true;
}
else if (uiTriggerId == AREATRIGGER_ALTAR && !m_bHasAltarYelled)
{
DoOrSimulateScriptTextForThisInstance(SAY_MINION_DESTROY, NPC_HAKKAR);
m_bHasAltarYelled = true;
}
}
Creature* SelectRandomPantherTrigger(bool bIsLeft)
{
GuidList* plTempList = bIsLeft ? &m_lLeftPantherTriggerGUIDList : &m_lRightPantherTriggerGUIDList;
std::vector<Creature*> vTriggers;
vTriggers.reserve(plTempList->size());
for (GuidList::const_iterator itr = plTempList->begin(); itr != plTempList->end(); ++itr)
{
if (Creature* pTemp = instance->GetCreature(*itr))
{
vTriggers.push_back(pTemp);
}
}
if (vTriggers.empty())
{
return nullptr;
}
return vTriggers[urand(0, vTriggers.size() - 1)];
}
uint32 m_auiEncounter[MAX_ENCOUNTER];
std::string m_strInstData;
GuidList m_lRightPantherTriggerGUIDList;
GuidList m_lLeftPantherTriggerGUIDList;
GuidList m_lSpiderEggGUIDList;
bool m_bHasIntroYelled;
bool m_bHasAltarYelled;
};
InstanceData* GetInstanceData(Map* pMap) override
{
return new instance_zulgurub(pMap);
}
};
struct at_zulgurub : public AreaTriggerScript
{
at_zulgurub() : AreaTriggerScript("at_zulgurub") {}
bool AreaTrigger_at_zulgurub(Player* pPlayer, AreaTriggerEntry const* pAt)
{
if (pAt->id == AREATRIGGER_ENTER || pAt->id == AREATRIGGER_ALTAR)
{
if (pPlayer->isGameMaster() || pPlayer->IsDead())
{
return false;
}
if (ScriptedInstance* pInstance = (ScriptedInstance*)pPlayer->GetInstanceData())
{
pInstance->SetData(TYPE_SIGNAL_1, pAt->id);
}
}
return false;
}
};
void AddSC_instance_zulgurub()
{
Script* s;
s = new is_zulgurub();
s->RegisterSelf();
s = new at_zulgurub();
s->RegisterSelf();
//pNewScript = new Script;
//pNewScript->Name = "instance_zulgurub";
//pNewScript->GetInstanceData = &GetInstanceData_instance_zulgurub;
//pNewScript->RegisterSelf();
//pNewScript = new Script;
//pNewScript->Name = "at_zulgurub";
//pNewScript->pAreaTrigger = &AreaTrigger_at_zulgurub;
//pNewScript->RegisterSelf();
}
| 32.617143 | 148 | 0.530221 | ZON3DEV |
b4c8ba33533492c15aee8d37ddd5e8f71a5c8c73 | 9,822 | cpp | C++ | tools/rpc_replay/rpc_replay.cpp | coxin12/brpc | 3d9a6ec81b74c875464fab1a6ab2ebf6081cadaa | [
"Apache-2.0"
] | 1 | 2021-03-21T14:41:57.000Z | 2021-03-21T14:41:57.000Z | tools/rpc_replay/rpc_replay.cpp | shaellancelot/brpc | 88481be8ab5ad23b30727ea17b27ce7557779690 | [
"Apache-2.0"
] | null | null | null | tools/rpc_replay/rpc_replay.cpp | shaellancelot/brpc | 88481be8ab5ad23b30727ea17b27ce7557779690 | [
"Apache-2.0"
] | 1 | 2018-03-13T10:29:40.000Z | 2018-03-13T10:29:40.000Z | // Copyright (c) 2014 Baidu, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Authors: Ge,Jun ([email protected])
#include <gflags/gflags.h>
#include <butil/logging.h>
#include <butil/time.h>
#include <butil/macros.h>
#include <butil/file_util.h>
#include <bvar/bvar.h>
#include <bthread/bthread.h>
#include <brpc/channel.h>
#include <brpc/server.h>
#include <brpc/rpc_dump.h>
#include <brpc/serialized_request.h>
#include "info_thread.h"
DEFINE_string(dir, "", "The directory of dumped requests");
DEFINE_int32(times, 1, "Repeat replaying for so many times");
DEFINE_int32(qps, 0, "Limit QPS if this flag is positive");
DEFINE_int32(thread_num, 0, "Number of threads for replaying");
DEFINE_bool(use_bthread, true, "Use bthread to replay");
DEFINE_string(connection_type, "", "Connection type, choose automatically "
"according to protocol by default");
DEFINE_string(server, "0.0.0.0:8002", "IP Address of server");
DEFINE_string(load_balancer, "", "The algorithm for load balancing");
DEFINE_int32(timeout_ms, 100, "RPC timeout in milliseconds");
DEFINE_int32(max_retry, 3, "Maximum retry times");
DEFINE_int32(dummy_port, 8899, "Port of dummy server(to monitor replaying)");
bvar::LatencyRecorder g_latency_recorder("rpc_replay");
bvar::Adder<int64_t> g_error_count("rpc_replay_error_count");
bvar::Adder<int64_t> g_sent_count;
// Include channels for all protocols that support both client and server.
class ChannelGroup {
public:
int Init();
~ChannelGroup();
// Get channel by protocol type.
brpc::Channel* channel(brpc::ProtocolType type) {
if ((size_t)type < _chans.size()) {
return _chans[(size_t)type];
}
return NULL;
}
private:
std::vector<brpc::Channel*> _chans;
};
int ChannelGroup::Init() {
{
// force global initialization of rpc.
brpc::Channel dummy_channel;
}
std::vector<std::pair<brpc::ProtocolType, brpc::Protocol> > protocols;
brpc::ListProtocols(&protocols);
size_t max_protocol_size = 0;
for (size_t i = 0; i < protocols.size(); ++i) {
max_protocol_size = std::max(max_protocol_size,
(size_t)protocols[i].first);
}
_chans.resize(max_protocol_size);
for (size_t i = 0; i < protocols.size(); ++i) {
if (protocols[i].second.support_client() &&
protocols[i].second.support_server()) {
const brpc::ProtocolType prot = protocols[i].first;
brpc::Channel* chan = new brpc::Channel;
brpc::ChannelOptions options;
options.protocol = prot;
options.connection_type = FLAGS_connection_type;
options.timeout_ms = FLAGS_timeout_ms/*milliseconds*/;
options.max_retry = FLAGS_max_retry;
if (chan->Init(FLAGS_server.c_str(), FLAGS_load_balancer.c_str(),
&options) != 0) {
LOG(ERROR) << "Fail to initialize channel";
return -1;
}
_chans[prot] = chan;
}
}
return 0;
}
ChannelGroup::~ChannelGroup() {
for (size_t i = 0; i < _chans.size(); ++i) {
delete _chans[i];
}
_chans.clear();
}
static void handle_response(brpc::Controller* cntl, int64_t start_time,
bool sleep_on_error/*note*/) {
// TODO(gejun): some bthreads are starved when new bthreads are created
// continuously, which happens when server is down and RPC keeps failing.
// Sleep a while on error to avoid that now.
const int64_t end_time = butil::gettimeofday_us();
const int64_t elp = end_time - start_time;
if (!cntl->Failed()) {
g_latency_recorder << elp;
} else {
g_error_count << 1;
if (sleep_on_error) {
bthread_usleep(10000);
}
}
delete cntl;
}
butil::atomic<int> g_thread_offset(0);
static void* replay_thread(void* arg) {
ChannelGroup* chan_group = static_cast<ChannelGroup*>(arg);
const int thread_offset = g_thread_offset.fetch_add(1, butil::memory_order_relaxed);
double req_rate = FLAGS_qps / (double)FLAGS_thread_num;
brpc::SerializedRequest req;
std::deque<int64_t> timeq;
size_t MAX_QUEUE_SIZE = (size_t)req_rate;
if (MAX_QUEUE_SIZE < 100) {
MAX_QUEUE_SIZE = 100;
} else if (MAX_QUEUE_SIZE > 2000) {
MAX_QUEUE_SIZE = 2000;
}
timeq.push_back(butil::gettimeofday_us());
for (int i = 0; !brpc::IsAskedToQuit() && i < FLAGS_times; ++i) {
brpc::SampleIterator it(FLAGS_dir);
int j = 0;
for (brpc::SampledRequest* sample = it.Next();
!brpc::IsAskedToQuit() && sample != NULL; sample = it.Next(), ++j) {
std::unique_ptr<brpc::SampledRequest> sample_guard(sample);
if ((j % FLAGS_thread_num) != thread_offset) {
continue;
}
brpc::Channel* chan =
chan_group->channel(sample->protocol_type());
if (chan == NULL) {
LOG(ERROR) << "No channel on protocol="
<< sample->protocol_type();
continue;
}
brpc::Controller* cntl = new brpc::Controller;
req.Clear();
cntl->reset_rpc_dump_meta(sample_guard.release());
if (sample->attachment_size() > 0) {
sample->request.cutn(
&req.serialized_data(),
sample->request.size() - sample->attachment_size());
cntl->request_attachment() = sample->request.movable();
} else {
req.serialized_data() = sample->request.movable();
}
g_sent_count << 1;
const int64_t start_time = butil::gettimeofday_us();
if (FLAGS_qps <= 0) {
chan->CallMethod(NULL/*use rpc_dump_context in cntl instead*/,
cntl, &req, NULL/*ignore response*/, NULL);
handle_response(cntl, start_time, true);
} else {
google::protobuf::Closure* done =
brpc::NewCallback(handle_response, cntl, start_time, false);
chan->CallMethod(NULL/*use rpc_dump_context in cntl instead*/,
cntl, &req, NULL/*ignore response*/, done);
const int64_t end_time = butil::gettimeofday_us();
int64_t expected_elp = 0;
int64_t actual_elp = 0;
timeq.push_back(end_time);
if (timeq.size() > MAX_QUEUE_SIZE) {
actual_elp = end_time - timeq.front();
timeq.pop_front();
expected_elp = (size_t)(1000000 * timeq.size() / req_rate);
} else {
actual_elp = end_time - timeq.front();
expected_elp = (size_t)(1000000 * (timeq.size() - 1) / req_rate);
}
if (actual_elp < expected_elp) {
bthread_usleep(expected_elp - actual_elp);
}
}
}
}
return NULL;
}
int main(int argc, char* argv[]) {
// Parse gflags. We recommend you to use gflags as well.
GFLAGS_NS::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_dir.empty() ||
!butil::DirectoryExists(butil::FilePath(FLAGS_dir))) {
LOG(ERROR) << "--dir=<dir-of-dumped-files> is required";
return -1;
}
if (FLAGS_dummy_port >= 0) {
brpc::StartDummyServerAt(FLAGS_dummy_port);
}
ChannelGroup chan_group;
if (chan_group.Init() != 0) {
LOG(ERROR) << "Fail to init ChannelGroup";
return -1;
}
if (FLAGS_thread_num <= 0) {
if (FLAGS_qps <= 0) { // unlimited qps
FLAGS_thread_num = 50;
} else {
FLAGS_thread_num = FLAGS_qps / 10000;
if (FLAGS_thread_num < 1) {
FLAGS_thread_num = 1;
}
if (FLAGS_thread_num > 50) {
FLAGS_thread_num = 50;
}
}
}
std::vector<bthread_t> tids;
tids.resize(FLAGS_thread_num);
if (!FLAGS_use_bthread) {
for (int i = 0; i < FLAGS_thread_num; ++i) {
if (pthread_create(&tids[i], NULL, replay_thread, &chan_group) != 0) {
LOG(ERROR) << "Fail to create pthread";
return -1;
}
}
} else {
for (int i = 0; i < FLAGS_thread_num; ++i) {
if (bthread_start_background(
&tids[i], NULL, replay_thread, &chan_group) != 0) {
LOG(ERROR) << "Fail to create bthread";
return -1;
}
}
}
brpc::InfoThread info_thr;
brpc::InfoThreadOptions info_thr_opt;
info_thr_opt.latency_recorder = &g_latency_recorder;
info_thr_opt.error_count = &g_error_count;
info_thr_opt.sent_count = &g_sent_count;
if (!info_thr.start(info_thr_opt)) {
LOG(ERROR) << "Fail to create info_thread";
return -1;
}
for (int i = 0; i < FLAGS_thread_num; ++i) {
if (!FLAGS_use_bthread) {
pthread_join(tids[i], NULL);
} else {
bthread_join(tids[i], NULL);
}
}
info_thr.stop();
return 0;
}
| 35.716364 | 88 | 0.582264 | coxin12 |
b4c96c9995e47735e8c51f89cf4515a8855830f6 | 1,658 | hpp | C++ | android-31/android/service/notification/NotificationListenerService_Ranking.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/service/notification/NotificationListenerService_Ranking.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-31/android/service/notification/NotificationListenerService_Ranking.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #pragma once
#include "../../../JObject.hpp"
namespace android::app
{
class NotificationChannel;
}
namespace android::content::pm
{
class ShortcutInfo;
}
class JString;
class JObject;
class JString;
namespace android::service::notification
{
class NotificationListenerService_Ranking : public JObject
{
public:
// Fields
static jint USER_SENTIMENT_NEGATIVE();
static jint USER_SENTIMENT_NEUTRAL();
static jint USER_SENTIMENT_POSITIVE();
static jint VISIBILITY_NO_OVERRIDE();
// QJniObject forward
template<typename ...Ts> explicit NotificationListenerService_Ranking(const char *className, const char *sig, Ts...agv) : JObject(className, sig, std::forward<Ts>(agv)...) {}
NotificationListenerService_Ranking(QJniObject obj);
// Constructors
NotificationListenerService_Ranking();
// Methods
jboolean canBubble() const;
jboolean canShowBadge() const;
jboolean equals(JObject arg0) const;
android::app::NotificationChannel getChannel() const;
android::content::pm::ShortcutInfo getConversationShortcutInfo() const;
jint getImportance() const;
JString getImportanceExplanation() const;
JString getKey() const;
jlong getLastAudiblyAlertedMillis() const;
jint getLockscreenVisibilityOverride() const;
JString getOverrideGroupKey() const;
jint getRank() const;
JObject getSmartActions() const;
JObject getSmartReplies() const;
jint getSuppressedVisualEffects() const;
jint getUserSentiment() const;
jboolean isAmbient() const;
jboolean isConversation() const;
jboolean isSuspended() const;
jboolean matchesInterruptionFilter() const;
};
} // namespace android::service::notification
| 28.101695 | 176 | 0.764777 | YJBeetle |
b4cd3db2b61d2df2b7acb44a0d4910af8ba5d18b | 7,493 | hpp | C++ | heart/src/solver/electrics/monodomain/MonodomainPurkinjeSolver.hpp | SoftMatterMechanics/ApicalStressFibers | 17d343c09a246a50f9e3a3cbfc399ca6bef353ce | [
"Apache-2.0",
"BSD-3-Clause"
] | 1 | 2020-09-10T16:12:13.000Z | 2020-09-10T16:12:13.000Z | heart/src/solver/electrics/monodomain/MonodomainPurkinjeSolver.hpp | SoftMatterMechanics/ApicalStressFibers | 17d343c09a246a50f9e3a3cbfc399ca6bef353ce | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | heart/src/solver/electrics/monodomain/MonodomainPurkinjeSolver.hpp | SoftMatterMechanics/ApicalStressFibers | 17d343c09a246a50f9e3a3cbfc399ca6bef353ce | [
"Apache-2.0",
"BSD-3-Clause"
] | 1 | 2020-09-10T16:12:21.000Z | 2020-09-10T16:12:21.000Z | /*
Copyright (c) 2005-2020, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
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 University of Oxford nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MONODOMAINPURKINJESOLVER_HPP_
#define MONODOMAINPURKINJESOLVER_HPP_
#include "AbstractDynamicLinearPdeSolver.hpp"
#include "MassMatrixAssembler.hpp"
#include "NaturalNeumannSurfaceTermAssembler.hpp"
#include "MonodomainCorrectionTermAssembler.hpp"
#include "MonodomainTissue.hpp"
#include "MonodomainPurkinjeVolumeAssembler.hpp"
#include "MonodomainPurkinjeCableAssembler.hpp"
/**
* Solver class for Monodomain problems on tissues containing Purkinje fibres.
*
* In such problems, there are a subset of nodes of the mesh which are labelled as
* Purkinje nodes (and 1D elements connecting them). There are two variables to be
* computed, the (normal, myocardium) transmembrane voltage (V), defined at ALL nodes
* of the mesh, and the Purkinje voltage (Vp), defined at the purkinje nodes. Hence, the
* Purkinje nodes have two variables defined on them.
*
* For parallelisation/implementation reasons, we choose to have two variables to be
* defined at ALL nodes, introducing dummy variables Vp for non-Purkinje nodes. We set
* Vp = 0 at non-Purkinje nodes. Hence we solve for {V,Vp} at every node in the mesh,
* and PROBLEM_DIM=2. The linear system to be assembled, written as usual in block form
* but actually in striped form in the code, is:
*
* [ A1 0 ][V ] = [b1]
* [ 0 A2 ][Vp] = [b2]
*
* where each block is of size num_nodes.
*
* A1 and b1 are obtained by integrating over 3D myocardium elements and are therefore
* exactly the same as in a normal monodomain problem.
*
* Suppose the nodes are ordered such that all the Purkinje nodes are last. Then the matrix A2
* needs to be of the form
* A2 = [I 0 ]
* [0 Ap]
* where the first block is of size num_non_purkinje_nodes, and the second is of size num_purkinje_nodes.
* Ap is obtained by assembling over 1D purkinje elements. After assembly we add in the identity block,
* which is just represents the equations Vp=0 for the dummy variables (non-purkinje nodes). Finally,
* we similarly have
* b2 = [0 ]
* [bp]
* where bp involves a loop over 1D purkinje elements.
*
* This class implements the above, and is based on (but doesn't inherit from, as the PROBLEM_DIMENSION
* is different) MonodomainSolver.
*
*
*/
template<unsigned ELEMENT_DIM, unsigned SPACE_DIM>
class MonodomainPurkinjeSolver
: public AbstractDynamicLinearPdeSolver<ELEMENT_DIM,SPACE_DIM,2>
{
private:
/** Saved pointer to the mesh in this class, as the pointer saved in the
* parent class (AbstractDynamicLinearPdeSolver::mpMesh) is not declared to
* be a pointer to a mixed mesh
*/
MixedDimensionMesh<ELEMENT_DIM,SPACE_DIM>* mpMixedMesh;
/** Monodomain tissue class (collection of cells, and conductivities) */
MonodomainTissue<ELEMENT_DIM,SPACE_DIM>* mpMonodomainTissue;
/** Boundary conditions */
BoundaryConditionsContainer<ELEMENT_DIM,SPACE_DIM,2>* mpBoundaryConditions;
/**
* The volume assembler, used to set up volume integral parts of the
* LHS matrix
*/
MonodomainPurkinjeVolumeAssembler<ELEMENT_DIM,SPACE_DIM>* mpVolumeAssembler;
/**
* The cable element assembler, used to set up cable integral parts of the
* LHS matrix
*/
MonodomainPurkinjeCableAssembler<ELEMENT_DIM,SPACE_DIM>* mpCableAssembler;
/** Assembler for surface integrals coming from any non-zero Neumann boundary conditions */
NaturalNeumannSurfaceTermAssembler<ELEMENT_DIM,SPACE_DIM,2>* mpNeumannSurfaceTermsAssembler;
// SVI and Purkinje not yet implemented:
// MonodomainCorrectionTermAssembler<ELEMENT_DIM,SPACE_DIM>* mpMonodomainCorrectionTermAssembler;
/** The mass matrix, used to computing the RHS vector */
Mat mMassMatrix;
/** The vector multiplied by the mass matrix. Ie, if the linear system to
* be solved is Ax=b (excluding surface integrals), this vector is z where b=Mz.
*/
Vec mVecForConstructingRhs;
/**
* Implementation of SetupLinearSystem() which uses the assembler to compute the
* LHS matrix, but sets up the RHS vector using the mass-matrix (constructed
* using a separate assembler) multiplied by a vector
*
* @param currentSolution Solution at current time
* @param computeMatrix Whether to compute the matrix of the linear system
*/
void SetupLinearSystem(Vec currentSolution, bool computeMatrix);
/**
* For the block in the LHS matrix corresponding to the Purkinje voltage at myocardium nodes:
* this block is zero after all elements are assembled so, so we set it to be the
* identity block. This is done by just checking which rows of the matrix has zero
* diagonal values.
*/
void SetIdentityBlockToLhsMatrix();
public:
/**
* Overloaded PrepareForSetupLinearSystem() methods which
* gets the cell models to solve themselves
*
* @param currentSolution solution at current time
*/
void PrepareForSetupLinearSystem(Vec currentSolution);
/**
* Overloaded InitialiseForSolve
*
* @param initialSolution initial solution
*/
virtual void InitialiseForSolve(Vec initialSolution);
/**
* Constructor
*
* @param pMesh pointer to the mesh
* @param pTissue pointer to the tissue
* @param pBoundaryConditions pointer to the boundary conditions
*/
MonodomainPurkinjeSolver(MixedDimensionMesh<ELEMENT_DIM,SPACE_DIM>* pMesh,
MonodomainTissue<ELEMENT_DIM,SPACE_DIM>* pTissue,
BoundaryConditionsContainer<ELEMENT_DIM,SPACE_DIM,2>* pBoundaryConditions);
/**
* Destructor
*/
virtual ~MonodomainPurkinjeSolver();
};
#endif // MONODOMAINPURKINJESOLVER_HPP_
| 40.722826 | 106 | 0.73949 | SoftMatterMechanics |
b4d360a6b712b22de80a1575c1c5a6da1e560128 | 5,130 | cpp | C++ | src/kl25_tsi.cpp | jlsalvat/mbed_frdm-kl25z | cdb70a1e39108d04dd110eb3ffe1a8056fa2e198 | [
"Unlicense"
] | 1 | 2019-11-16T19:37:57.000Z | 2019-11-16T19:37:57.000Z | src/kl25_tsi.cpp | jlsalvat/mbed_frdm-kl25z | cdb70a1e39108d04dd110eb3ffe1a8056fa2e198 | [
"Unlicense"
] | null | null | null | src/kl25_tsi.cpp | jlsalvat/mbed_frdm-kl25z | cdb70a1e39108d04dd110eb3ffe1a8056fa2e198 | [
"Unlicense"
] | null | null | null | #include "kl25_tsi.h"
#include "mbed.h"
/******************************************************************************
* Example 1 : put a cable on A0 pin and touch this pin for lighting red light
#include "mbed.h"
DigitalOut red(LED_RED);
int main(){
uint16_t sense_A0;
tsiInit(TSI_CURRENT_8uA, TSI_CURRENT_64uA, TSI_DV_1_03V, TSI_DIV_16, TSI_12_SCAN);
TSIChannelName channel= tsiActivateChannel(A0);
while(1) {
sense_A0 = 0;
tsiStart((TSIChannelName)channel);
while(!tsiAvalaible()) {
sense_A0= tsiRead();
printf("TOUCH: %d\r\n", sense_A0);
}
if(sense_A0<380)
red=1;
else
red=0;
}
}
*********************************************************************/
/********************************************************************
* Example read TSI in interrupt
#include "mbed.h"
DigitalOut red(LED_RED);
TSIChannelName gChannel;
void ISR_TSI0(){
gFlagTSI=true;
fgpioToggle(FPTA, 12); // D3 out
tsiStart(gChannel);
}
int main(){
uint16_t sense_A0;
tsiInit(TSI_CURRENT_8uA, TSI_CURRENT_64uA, TSI_DV_1_03V, TSI_DIV_16, TSI_12_SCAN);
gChannel= tsiActivateChannel(A0);
tsiSetTreshold(375,330);
tsiEnableInterrupt();
tsiStart(gChannel);
tsi_attachInterrupt(ISR_TSI0);
while(1) {
sense_A0 = 0;
wait(0.1);
if(gFlagTSI){
sense_A0= tsiRead();
printf("TOUCH: %d\r\n", sense_A0);
if (red.read() == 0)
red= 1;
else
red = 0;
gFlagTSI=false;
}
}
}
**********************************************************/
void (*fTSI0)(void);
// RAM interrupt handler relocated
void TSI0_IRQ_Handler(){
fTSI0();
TSI0->GENCS |=TSI_GENCS_OUTRGF_MASK ;//clear TOF
}
void tsiInit(TSI_Charge_Current refChg, TSI_Charge_Current extChg, TSI_DV dvolt, TSI_DIV_PRESCALER ps, TSI_NUMBER_OF_SCAN nscn) {
// The first version is preconfigured for non-noise detection, no interrupts, not running on stop modes, software trigger
SIM->SCGC5 |= SIM_SCGC5_TSI_MASK; // clock gate for TSI
TSI0->GENCS = 0xC0000080 | ((refChg & 0x07) << 21) | ((extChg & 0x07) << 16) | ((dvolt & 0x03) << 19) | ((ps & 0x07) << 13) | ((nscn & 0x1F) << 8);
}
/* Function to configure a pin to work with the corresponding channel (passed as the single parameter) */
TSIChannelName tsiActivateChannel(PinName pin) {
// reads channel number and sets the MUX of the corresponding pin to ALT0 function
unsigned int port = (unsigned int)pin >> PORT_SHIFT;
unsigned int pin_n = (pin&0xFF)>>2;
switch(port){
case 0: SIM->SCGC5|=SIM_SCGC5_PORTA_MASK; break;
case 1: SIM->SCGC5|=SIM_SCGC5_PORTB_MASK; break;
case 2: SIM->SCGC5|=SIM_SCGC5_PORTC_MASK; break;
}
TSIChannelName channel = (TSIChannelName)pinmap_peripheral(pin, PinMap_TSI);
if(((int)channel)==NC)
error("PinName provided to tsiActivateChannel() does not correspond to any known TSI channel.");
printf("port=%d, pn_n=%d, channel=%d\n\r",port,pin_n,channel);
PORT_Type *port_reg = (PORT_Type *)(PORTA_BASE + 0x1000 *port);
port_reg->PCR[pin_n] &= ~PORT_PCR_MUX_MASK;//choose ALT0 pin
return channel;
}
// Function to trigger the reading of a given channel
void tsiStart(TSIChannelName channel) {
//writes 1 to the software trigger bit, defining the channel number in the respective bits
TSI0->GENCS |= TSI_GENCS_EOSF_MASK; // clears EOSF
TSI0->DATA = TSI_DATA_SWTS_MASK | TSI_DATA_TSICH(channel);
}
void tsiSetTreshold(uint16_t tresholdHigh,uint16_t tresholdLow){
unsigned int tshd = (tresholdLow&0xFFFF) | (tresholdHigh<<16);
TSI0->TSHD=tshd;
printf("treshold=%x\n\r",tshd);
}
void tsiEnableInterruptOnTreshold(){
TSI0->GENCS|=TSI_GENCS_TSIIEN_MASK;//The interrupt will wake MCU from low power mode if this interrupt is enabled.
TSI0->GENCS|=TSI_GENCS_STPE_MASK;//This bit enables TSI module function in low power modes
TSI0->GENCS&=~TSI_GENCS_ESOR_MASK;//0 Out-of-range interrupt is allowed.
}
void tsiEnableInterrupt(){
TSI0->GENCS|=TSI_GENCS_TSIIEN_MASK; //This bit enables TSI module interrupt request to CPU when the scan completes
TSI0->GENCS|=TSI_GENCS_ESOR_MASK;//1 End-of-scan interrupt is allowed.
}
void tsiDisableInterrupt(){
TSI0->GENCS&=~TSI_GENCS_TSIIEN_MASK;//The interrupt will wake MCU from low power mode if this interrupt is enabled.
TSI0->GENCS&=~TSI_GENCS_STPE_MASK;//This bit enables TSI module function in low power modes
}
void tsi_attachTSI0_IRQHandler(){
NVIC_EnableIRQ(TSI0_IRQn);
__enable_irq();
}
void tsi_attachInterrupt(void (*userFunc)(void)){
fTSI0 = userFunc;
NVIC_SetVector(TSI0_IRQn, (uint32_t)TSI0_IRQ_Handler);
NVIC_EnableIRQ(TSI0_IRQn);
__enable_irq();
}
void tsi_dettachInterrupt(){
NVIC_DisableIRQ(TSI0_IRQn);
}
// Function to read scan result; returns zero if not finished
uint16_t tsiRead() {
uint16_t aux;
aux = TSI0->DATA & 0x0000FFFF;
TSI0->GENCS |= TSI_GENCS_EOSF_MASK; // clears EOSF
return aux;
}
| 34.897959 | 151 | 0.64386 | jlsalvat |
b4d83621cae5c1d2d77fddcdbb56b3331e22b7a9 | 252 | cpp | C++ | src/kriti/TimeValue.cpp | etherealvisage/kriti | 6397c4d20331d9f5ce07460df08bbac9653ffa8b | [
"BSD-3-Clause"
] | 2 | 2015-10-05T19:33:19.000Z | 2015-12-08T08:39:17.000Z | src/kriti/TimeValue.cpp | etherealvisage/kriti | 6397c4d20331d9f5ce07460df08bbac9653ffa8b | [
"BSD-3-Clause"
] | 1 | 2017-04-30T16:26:08.000Z | 2017-05-01T03:00:42.000Z | src/kriti/TimeValue.cpp | etherealvisage/kriti | 6397c4d20331d9f5ce07460df08bbac9653ffa8b | [
"BSD-3-Clause"
] | null | null | null | #include <time.h>
#include "TimeValue.h"
namespace Kriti {
TimeValue TimeValue::current() {
struct timespec current;
clock_gettime(CLOCK_MONOTONIC, ¤t);
return current.tv_nsec + current.tv_sec*1000000000;
}
} // namespace Kriti
| 16.8 | 55 | 0.718254 | etherealvisage |
b4d8f1b7d1c9ce6f4f1739de3b99b23960b45c80 | 4,471 | hpp | C++ | src/oatpp/codegen/api_controller/base_undef.hpp | Purlemon/oatpp | 128816a027ca82f8de8da5bad445641e71fb437f | [
"Apache-2.0"
] | 5,252 | 2018-04-04T13:52:44.000Z | 2022-03-31T13:42:28.000Z | src/oatpp/codegen/api_controller/base_undef.hpp | Purlemon/oatpp | 128816a027ca82f8de8da5bad445641e71fb437f | [
"Apache-2.0"
] | 416 | 2018-04-22T14:03:25.000Z | 2022-03-31T13:30:56.000Z | src/oatpp/codegen/api_controller/base_undef.hpp | Purlemon/oatpp | 128816a027ca82f8de8da5bad445641e71fb437f | [
"Apache-2.0"
] | 1,140 | 2018-07-31T10:09:52.000Z | 2022-03-31T19:18:13.000Z | /***************************************************************************
*
* Project _____ __ ____ _ _
* ( _ ) /__\ (_ _)_| |_ _| |_
* )(_)( /(__)\ )( (_ _)(_ _)
* (_____)(__)(__)(__) |_| |_|
*
*
* Copyright 2018-present, Leonid Stryzhevskyi <[email protected]>
*
* 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.
*
***************************************************************************/
#undef OATPP_MACRO_API_CONTROLLER_PARAM_MACRO
#undef OATPP_MACRO_API_CONTROLLER_PARAM_INFO
#undef OATPP_MACRO_API_CONTROLLER_PARAM_TYPE
#undef OATPP_MACRO_API_CONTROLLER_PARAM_NAME
#undef OATPP_MACRO_API_CONTROLLER_PARAM_TYPE_STR
#undef OATPP_MACRO_API_CONTROLLER_PARAM_NAME_STR
#undef OATPP_MACRO_API_CONTROLLER_PARAM
#undef REQUEST
#undef HEADER
#undef PATH
#undef QUERIES
#undef QUERY
#undef BODY_STRING
#undef BODY_DTO
// INIT // ------------------------------------------------------
#undef REST_CONTROLLER_INIT
#undef OATPP_MACRO_API_CONTROLLER_MACRO_SELECTOR
// REQUEST MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_REQUEST
#undef OATPP_MACRO_API_CONTROLLER_REQUEST_INFO
// HEADER MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_HEADER_1
#undef OATPP_MACRO_API_CONTROLLER_HEADER_2
#undef OATPP_MACRO_API_CONTROLLER_HEADER
// __INFO
#undef OATPP_MACRO_API_CONTROLLER_HEADER_INFO_1
#undef OATPP_MACRO_API_CONTROLLER_HEADER_INFO_2
#undef OATPP_MACRO_API_CONTROLLER_HEADER_INFO
// PATH MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_PATH_1
#undef OATPP_MACRO_API_CONTROLLER_PATH_2
#undef OATPP_MACRO_API_CONTROLLER_PATH
// __INFO
#undef OATPP_MACRO_API_CONTROLLER_PATH_INFO_1
#undef OATPP_MACRO_API_CONTROLLER_PATH_INFO_2
#undef OATPP_MACRO_API_CONTROLLER_PATH_INFO
// QUERIES MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_QUERIES
#undef OATPP_MACRO_API_CONTROLLER_QUERIES_INFO
// QUERY MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_QUERY_1
#undef OATPP_MACRO_API_CONTROLLER_QUERY_2
#undef OATPP_MACRO_API_CONTROLLER_QUERY
// __INFO
#undef OATPP_MACRO_API_CONTROLLER_QUERY_INFO_1
#undef OATPP_MACRO_API_CONTROLLER_QUERY_INFO_2
#undef OATPP_MACRO_API_CONTROLLER_QUERY_INFO
// BODY_STRING MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_BODY_STRING
// __INFO
#undef OATPP_MACRO_API_CONTROLLER_BODY_STRING_INFO
// BODY_DTO MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_BODY_DTO
// __INFO
#undef OATPP_MACRO_API_CONTROLLER_BODY_DTO_INFO
// FOR EACH // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_FOR_EACH_PARAM_DECL
#undef OATPP_MACRO_API_CONTROLLER_FOR_EACH_PARAM_PUT
#undef OATPP_MACRO_API_CONTROLLER_FOR_EACH_PARAM_CALL
#undef OATPP_MACRO_API_CONTROLLER_FOR_EACH_PARAM_INFO
// ENDPOINT_INFO MACRO // ------------------------------------------------------
#undef ENDPOINT_INFO
// ENDPOINT MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_DECL_DEFAULTS
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_DECL_0
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_0
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_DECL_1
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_1
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_MACRO_0
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_MACRO_1
#undef ENDPOINT
#undef ENDPOINT_INTERCEPTOR
// ENDPOINT ASYNC MACRO // ------------------------------------------------------
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_ASYNC_DECL_DEFAULTS
#undef OATPP_MACRO_API_CONTROLLER_ENDPOINT_ASYNC_DECL
#undef ENDPOINT_ASYNC
#undef ENDPOINT_ASYNC_INIT
#undef ENDPOINT_INTERCEPTOR_ASYNC
| 30.834483 | 81 | 0.669425 | Purlemon |
b4db1d7e68a00024cf8e4ef64494ce6f134282b0 | 26,522 | cpp | C++ | dependencies/FreeImage/FreeImage/PluginPNG.cpp | sumneko/BLPConverter | 792392375061b80f3275f04353715b183309f91f | [
"MIT"
] | 53 | 2015-01-21T02:20:04.000Z | 2022-03-14T20:52:10.000Z | dependencies/FreeImage/FreeImage/PluginPNG.cpp | sumneko/BLPConverter | 792392375061b80f3275f04353715b183309f91f | [
"MIT"
] | 5 | 2016-01-10T08:54:22.000Z | 2020-09-10T14:58:23.000Z | dependencies/FreeImage/FreeImage/PluginPNG.cpp | sumneko/BLPConverter | 792392375061b80f3275f04353715b183309f91f | [
"MIT"
] | 29 | 2015-02-13T13:42:23.000Z | 2021-12-22T16:04:47.000Z | // ==========================================================
// PNG Loader and Writer
//
// Design and implementation by
// - Floris van den Berg ([email protected])
// - Herve Drolon ([email protected])
// - Detlev Vendt ([email protected])
// - Aaron Shumate ([email protected])
//
// This file is part of FreeImage 3
//
// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================
#ifdef _MSC_VER
#pragma warning (disable : 4786) // identifier was truncated to 'number' characters
#endif
#include "FreeImage.h"
#include "Utilities.h"
#include "../Metadata/FreeImageTag.h"
// ----------------------------------------------------------
#define PNG_BYTES_TO_CHECK 8
// ----------------------------------------------------------
#include "../LibPNG/png.h"
// ----------------------------------------------------------
typedef struct {
FreeImageIO *s_io;
fi_handle s_handle;
} fi_ioStructure, *pfi_ioStructure;
/////////////////////////////////////////////////////////////////////////////
// libpng interface
//
static void
_ReadProc(png_structp png_ptr, unsigned char *data, png_size_t size) {
pfi_ioStructure pfio = (pfi_ioStructure)png_get_io_ptr(png_ptr);
unsigned n = pfio->s_io->read_proc(data, (unsigned int)size, 1, pfio->s_handle);
if(size && (n == 0)) {
throw "Read error: invalid or corrupted PNG file";
}
}
static void
_WriteProc(png_structp png_ptr, unsigned char *data, png_size_t size) {
pfi_ioStructure pfio = (pfi_ioStructure)png_get_io_ptr(png_ptr);
pfio->s_io->write_proc(data, (unsigned int)size, 1, pfio->s_handle);
}
static void
_FlushProc(png_structp png_ptr) {
// empty flush implementation
}
static void
error_handler(png_structp png_ptr, const char *error) {
throw error;
}
// in FreeImage warnings disabled
static void
warning_handler(png_structp png_ptr, const char *warning) {
}
// ==========================================================
// Metadata routines
// ==========================================================
static BOOL
ReadMetadata(png_structp png_ptr, png_infop info_ptr, FIBITMAP *dib) {
// XMP keyword
char *g_png_xmp_keyword = "XML:com.adobe.xmp";
FITAG *tag = NULL;
png_textp text_ptr = NULL;
int num_text = 0;
// iTXt/tEXt/zTXt chuncks
if(png_get_text(png_ptr, info_ptr, &text_ptr, &num_text) > 0) {
for(int i = 0; i < num_text; i++) {
// create a tag
tag = FreeImage_CreateTag();
if(!tag) return FALSE;
DWORD tag_length = (DWORD) MAX(text_ptr[i].text_length, text_ptr[i].itxt_length);
FreeImage_SetTagLength(tag, tag_length);
FreeImage_SetTagCount(tag, tag_length);
FreeImage_SetTagType(tag, FIDT_ASCII);
FreeImage_SetTagValue(tag, text_ptr[i].text);
if(strcmp(text_ptr[i].key, g_png_xmp_keyword) == 0) {
// store the tag as XMP
FreeImage_SetTagKey(tag, g_TagLib_XMPFieldName);
FreeImage_SetMetadata(FIMD_XMP, dib, FreeImage_GetTagKey(tag), tag);
} else {
// store the tag as a comment
FreeImage_SetTagKey(tag, text_ptr[i].key);
FreeImage_SetMetadata(FIMD_COMMENTS, dib, FreeImage_GetTagKey(tag), tag);
}
// destroy the tag
FreeImage_DeleteTag(tag);
}
}
return TRUE;
}
static BOOL
WriteMetadata(png_structp png_ptr, png_infop info_ptr, FIBITMAP *dib) {
// XMP keyword
char *g_png_xmp_keyword = "XML:com.adobe.xmp";
FITAG *tag = NULL;
FIMETADATA *mdhandle = NULL;
BOOL bResult = TRUE;
png_text text_metadata;
// set the 'Comments' metadata as iTXt chuncks
mdhandle = FreeImage_FindFirstMetadata(FIMD_COMMENTS, dib, &tag);
if(mdhandle) {
do {
memset(&text_metadata, 0, sizeof(png_text));
text_metadata.compression = 1; // iTXt, none
text_metadata.key = (char*)FreeImage_GetTagKey(tag); // keyword, 1-79 character description of "text"
text_metadata.text = (char*)FreeImage_GetTagValue(tag); // comment, may be an empty string (ie "")
text_metadata.text_length = FreeImage_GetTagLength(tag);// length of the text string
text_metadata.itxt_length = FreeImage_GetTagLength(tag);// length of the itxt string
text_metadata.lang = 0; // language code, 0-79 characters or a NULL pointer
text_metadata.lang_key = 0; // keyword translated UTF-8 string, 0 or more chars or a NULL pointer
// set the tag
png_set_text(png_ptr, info_ptr, &text_metadata, 1);
} while(FreeImage_FindNextMetadata(mdhandle, &tag));
FreeImage_FindCloseMetadata(mdhandle);
bResult &= TRUE;
}
// set the 'XMP' metadata as iTXt chuncks
tag = NULL;
FreeImage_GetMetadata(FIMD_XMP, dib, g_TagLib_XMPFieldName, &tag);
if(tag && FreeImage_GetTagLength(tag)) {
memset(&text_metadata, 0, sizeof(png_text));
text_metadata.compression = 1; // iTXt, none
text_metadata.key = g_png_xmp_keyword; // keyword, 1-79 character description of "text"
text_metadata.text = (char*)FreeImage_GetTagValue(tag); // comment, may be an empty string (ie "")
text_metadata.text_length = FreeImage_GetTagLength(tag);// length of the text string
text_metadata.itxt_length = FreeImage_GetTagLength(tag);// length of the itxt string
text_metadata.lang = 0; // language code, 0-79 characters or a NULL pointer
text_metadata.lang_key = 0; // keyword translated UTF-8 string, 0 or more chars or a NULL pointer
// set the tag
png_set_text(png_ptr, info_ptr, &text_metadata, 1);
bResult &= TRUE;
}
return bResult;
}
// ==========================================================
// Plugin Interface
// ==========================================================
static int s_format_id;
// ==========================================================
// Plugin Implementation
// ==========================================================
static const char * DLL_CALLCONV
Format() {
return "PNG";
}
static const char * DLL_CALLCONV
Description() {
return "Portable Network Graphics";
}
static const char * DLL_CALLCONV
Extension() {
return "png";
}
static const char * DLL_CALLCONV
RegExpr() {
return "^.PNG\r";
}
static const char * DLL_CALLCONV
MimeType() {
return "image/png";
}
static BOOL DLL_CALLCONV
Validate(FreeImageIO *io, fi_handle handle) {
BYTE png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
BYTE signature[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
io->read_proc(&signature, 1, 8, handle);
return (memcmp(png_signature, signature, 8) == 0);
}
static BOOL DLL_CALLCONV
SupportsExportDepth(int depth) {
return (
(depth == 1) ||
(depth == 4) ||
(depth == 8) ||
(depth == 24) ||
(depth == 32)
);
}
static BOOL DLL_CALLCONV
SupportsExportType(FREE_IMAGE_TYPE type) {
return (
(type == FIT_BITMAP) ||
(type == FIT_UINT16) ||
(type == FIT_RGB16) ||
(type == FIT_RGBA16)
);
}
static BOOL DLL_CALLCONV
SupportsICCProfiles() {
return TRUE;
}
// ----------------------------------------------------------
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
png_structp png_ptr = NULL;
png_infop info_ptr;
png_uint_32 width, height;
png_colorp png_palette = NULL;
int color_type, palette_entries = 0;
int bit_depth, pixel_depth; // pixel_depth = bit_depth * channels
FIBITMAP *dib = NULL;
RGBQUAD *palette = NULL; // pointer to dib palette
png_bytepp row_pointers = NULL;
int i;
fi_ioStructure fio;
fio.s_handle = handle;
fio.s_io = io;
if (handle) {
try {
// check to see if the file is in fact a PNG file
BYTE png_check[PNG_BYTES_TO_CHECK];
io->read_proc(png_check, PNG_BYTES_TO_CHECK, 1, handle);
if (png_sig_cmp(png_check, (png_size_t)0, PNG_BYTES_TO_CHECK) != 0)
return NULL; // Bad signature
// create the chunk manage structure
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, error_handler, warning_handler);
if (!png_ptr)
return NULL;
// create the info structure
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
return NULL;
}
// init the IO
png_set_read_fn(png_ptr, &fio, _ReadProc);
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return NULL;
}
// because we have already read the signature...
png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK);
// read the IHDR chunk
png_read_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
pixel_depth = info_ptr->pixel_depth;
// get image data type (assume standard image type)
FREE_IMAGE_TYPE image_type = FIT_BITMAP;
if (bit_depth == 16) {
if ((pixel_depth == 16) && (color_type == PNG_COLOR_TYPE_GRAY)) {
image_type = FIT_UINT16;
}
else if ((pixel_depth == 48) && (color_type == PNG_COLOR_TYPE_RGB)) {
image_type = FIT_RGB16;
}
else if ((pixel_depth == 64) && (color_type == PNG_COLOR_TYPE_RGB_ALPHA)) {
image_type = FIT_RGBA16;
} else {
// tell libpng to strip 16 bit/color files down to 8 bits/color
png_set_strip_16(png_ptr);
bit_depth = 8;
}
}
#ifndef FREEIMAGE_BIGENDIAN
if((image_type == FIT_UINT16) || (image_type == FIT_RGB16) || (image_type == FIT_RGBA16)) {
// turn on 16 bit byte swapping
png_set_swap(png_ptr);
}
#endif
// set some additional flags
switch(color_type) {
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_RGB_ALPHA:
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// flip the RGB pixels to BGR (or RGBA to BGRA)
if(image_type == FIT_BITMAP)
png_set_bgr(png_ptr);
#endif
break;
case PNG_COLOR_TYPE_PALETTE:
// expand palette images to the full 8 bits from 2 bits/pixel
if (pixel_depth == 2) {
png_set_packing(png_ptr);
pixel_depth = 8;
}
break;
case PNG_COLOR_TYPE_GRAY:
// expand grayscale images to the full 8 bits from 2 bits/pixel
// but *do not* expand fully transparent palette entries to a full alpha channel
if (pixel_depth == 2) {
png_set_expand_gray_1_2_4_to_8(png_ptr);
pixel_depth = 8;
}
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
// expand 8-bit greyscale + 8-bit alpha to 32-bit
png_set_gray_to_rgb(png_ptr);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// flip the RGBA pixels to BGRA
png_set_bgr(png_ptr);
#endif
pixel_depth = 32;
break;
default:
throw FI_MSG_ERROR_UNSUPPORTED_FORMAT;
}
// Get the background color to draw transparent and alpha images over.
// Note that even if the PNG file supplies a background, you are not required to
// use it - you should use the (solid) application background if it has one.
png_color_16p image_background = NULL;
RGBQUAD rgbBkColor;
if (png_get_bKGD(png_ptr, info_ptr, &image_background)) {
rgbBkColor.rgbRed = (BYTE)image_background->red;
rgbBkColor.rgbGreen = (BYTE)image_background->green;
rgbBkColor.rgbBlue = (BYTE)image_background->blue;
rgbBkColor.rgbReserved = 0;
}
// unlike the example in the libpng documentation, we have *no* idea where
// this file may have come from--so if it doesn't have a file gamma, don't
// do any correction ("do no harm")
double gamma = 0;
double screen_gamma = 2.2;
if (png_get_gAMA(png_ptr, info_ptr, &gamma) && ( flags & PNG_IGNOREGAMMA ) != PNG_IGNOREGAMMA)
png_set_gamma(png_ptr, screen_gamma, gamma);
// all transformations have been registered; now update info_ptr data
png_read_update_info(png_ptr, info_ptr);
// color type may have changed, due to our transformations
color_type = png_get_color_type(png_ptr,info_ptr);
// create a DIB and write the bitmap header
// set up the DIB palette, if needed
switch (color_type) {
case PNG_COLOR_TYPE_RGB:
png_set_invert_alpha(png_ptr);
if(image_type == FIT_BITMAP) {
dib = FreeImage_Allocate(width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
} else {
dib = FreeImage_AllocateT(image_type, width, height, pixel_depth);
}
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
if(image_type == FIT_BITMAP) {
dib = FreeImage_Allocate(width, height, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
} else {
dib = FreeImage_AllocateT(image_type, width, height, pixel_depth);
}
break;
case PNG_COLOR_TYPE_PALETTE:
dib = FreeImage_Allocate(width, height, pixel_depth);
png_get_PLTE(png_ptr,info_ptr, &png_palette,&palette_entries);
palette = FreeImage_GetPalette(dib);
// store the palette
for (i = 0; i < palette_entries; i++) {
palette[i].rgbRed = png_palette[i].red;
palette[i].rgbGreen = png_palette[i].green;
palette[i].rgbBlue = png_palette[i].blue;
}
// store the transparency table
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
int num_trans = 0;
png_bytep trans = NULL;
png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
FreeImage_SetTransparencyTable(dib, (BYTE *)trans, num_trans);
}
break;
case PNG_COLOR_TYPE_GRAY:
dib = FreeImage_AllocateT(image_type, width, height, pixel_depth);
if(pixel_depth <= 8) {
palette = FreeImage_GetPalette(dib);
palette_entries = 1 << pixel_depth;
for (i = 0; i < palette_entries; i++) {
palette[i].rgbRed =
palette[i].rgbGreen =
palette[i].rgbBlue = (BYTE)((i * 255) / (palette_entries - 1));
}
}
// store the transparency table
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_color_16p trans_values = NULL;
png_get_tRNS(png_ptr, info_ptr, NULL, NULL, &trans_values);
if(trans_values) {
if (trans_values->gray < palette_entries) {
BYTE table[256];
memset(table, 0xFF, palette_entries);
table[trans_values->gray] = 0;
FreeImage_SetTransparencyTable(dib, table, palette_entries);
}
}
}
break;
default:
throw FI_MSG_ERROR_UNSUPPORTED_FORMAT;
}
// store the background color
if(image_background) {
FreeImage_SetBackgroundColor(dib, &rgbBkColor);
}
// get physical resolution
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) {
png_uint_32 res_x, res_y;
// we'll overload this var and use 0 to mean no phys data,
// since if it's not in meters we can't use it anyway
int res_unit_type = 0;
png_get_pHYs(png_ptr,info_ptr,&res_x,&res_y,&res_unit_type);
if (res_unit_type == 1) {
FreeImage_SetDotsPerMeterX(dib, res_x);
FreeImage_SetDotsPerMeterY(dib, res_y);
}
}
// get possible ICC profile
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_iCCP)) {
png_charp profile_name = NULL;
png_charp profile_data = NULL;
png_uint_32 profile_length = 0;
int compression_type;
png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &profile_length);
// copy ICC profile data (must be done after FreeImage_Allocate)
FreeImage_CreateICCProfile(dib, profile_data, profile_length);
}
// set the individual row_pointers to point at the correct offsets
row_pointers = (png_bytepp)malloc(height * sizeof(png_bytep));
if (!row_pointers) {
if (palette)
png_free(png_ptr, palette);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
FreeImage_Unload(dib);
return NULL;
}
// read in the bitmap bits via the pointer table
for (png_uint_32 k = 0; k < height; k++)
row_pointers[height - 1 - k] = FreeImage_GetScanLine(dib, k);
png_read_image(png_ptr, row_pointers);
// check if the bitmap contains transparency, if so enable it in the header
if (FreeImage_GetBPP(dib) == 32)
if (FreeImage_GetColorType(dib) == FIC_RGBALPHA)
FreeImage_SetTransparent(dib, TRUE);
else
FreeImage_SetTransparent(dib, FALSE);
// cleanup
if (row_pointers) {
free(row_pointers);
row_pointers = NULL;
}
// read the rest of the file, getting any additional chunks in info_ptr
png_read_end(png_ptr, info_ptr);
// get possible metadata (it can be located both before and after the image data)
ReadMetadata(png_ptr, info_ptr, dib);
if (png_ptr) {
// clean up after the read, and free any memory allocated - REQUIRED
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
}
return dib;
} catch (const char *text) {
if (png_ptr)
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
if (row_pointers)
free(row_pointers);
if (dib)
FreeImage_Unload(dib);
FreeImage_OutputMessageProc(s_format_id, text);
return NULL;
}
}
return NULL;
}
static BOOL DLL_CALLCONV
Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
png_structp png_ptr;
png_infop info_ptr;
png_colorp palette = NULL;
png_uint_32 width, height;
BOOL has_alpha_channel = FALSE;
RGBQUAD *pal; // pointer to dib palette
int bit_depth, pixel_depth; // pixel_depth = bit_depth * channels
int palette_entries;
int interlace_type;
fi_ioStructure fio;
fio.s_handle = handle;
fio.s_io = io;
if ((dib) && (handle)) {
try {
// create the chunk manage structure
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, error_handler, warning_handler);
if (!png_ptr) {
return FALSE;
}
// allocate/initialize the image information data.
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return FALSE;
}
// Set error handling. REQUIRED if you aren't supplying your own
// error handling functions in the png_create_write_struct() call.
if (setjmp(png_jmpbuf(png_ptr))) {
// if we get here, we had a problem reading the file
png_destroy_write_struct(&png_ptr, &info_ptr);
return FALSE;
}
// init the IO
png_set_write_fn(png_ptr, &fio, _WriteProc, _FlushProc);
// set physical resolution
png_uint_32 res_x = (png_uint_32)FreeImage_GetDotsPerMeterX(dib);
png_uint_32 res_y = (png_uint_32)FreeImage_GetDotsPerMeterY(dib);
if ((res_x > 0) && (res_y > 0)) {
png_set_pHYs(png_ptr, info_ptr, res_x, res_y, 1);
}
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
width = FreeImage_GetWidth(dib);
height = FreeImage_GetHeight(dib);
pixel_depth = FreeImage_GetBPP(dib);
BOOL bInterlaced = FALSE;
if( (flags & PNG_INTERLACED) == PNG_INTERLACED) {
interlace_type = PNG_INTERLACE_ADAM7;
bInterlaced = TRUE;
} else {
interlace_type = PNG_INTERLACE_NONE;
}
// set the ZLIB compression level or default to PNG default compression level (ZLIB level = 6)
int zlib_level = flags & 0x0F;
if((zlib_level >= 1) && (zlib_level <= 9)) {
png_set_compression_level(png_ptr, zlib_level);
} else if((flags & PNG_Z_NO_COMPRESSION) == PNG_Z_NO_COMPRESSION) {
png_set_compression_level(png_ptr, Z_NO_COMPRESSION);
}
// filtered strategy works better for high color images
if(pixel_depth >= 16){
png_set_compression_strategy(png_ptr, Z_FILTERED);
png_set_filter(png_ptr, 0, PNG_FILTER_NONE|PNG_FILTER_SUB|PNG_FILTER_PAETH);
} else {
png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
}
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
if(image_type == FIT_BITMAP) {
// standard image type
bit_depth = (pixel_depth > 8) ? 8 : pixel_depth;
} else {
// 16-bit greyscale or 16-bit RGB(A)
bit_depth = 16;
}
switch (FreeImage_GetColorType(dib)) {
case FIC_MINISWHITE:
// Invert monochrome files to have 0 as black and 1 as white (no break here)
png_set_invert_mono(png_ptr);
case FIC_MINISBLACK:
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
PNG_COLOR_TYPE_GRAY, interlace_type,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
break;
case FIC_PALETTE:
{
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
PNG_COLOR_TYPE_PALETTE, interlace_type,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
// set the palette
palette_entries = 1 << bit_depth;
palette = (png_colorp)png_malloc(png_ptr, palette_entries * sizeof (png_color));
pal = FreeImage_GetPalette(dib);
for (int i = 0; i < palette_entries; i++) {
palette[i].red = pal[i].rgbRed;
palette[i].green = pal[i].rgbGreen;
palette[i].blue = pal[i].rgbBlue;
}
png_set_PLTE(png_ptr, info_ptr, palette, palette_entries);
// You must not free palette here, because png_set_PLTE only makes a link to
// the palette that you malloced. Wait until you are about to destroy
// the png structure.
break;
}
case FIC_RGBALPHA :
has_alpha_channel = TRUE;
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
PNG_COLOR_TYPE_RGBA, interlace_type,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// flip BGR pixels to RGB
if(image_type == FIT_BITMAP)
png_set_bgr(png_ptr);
#endif
break;
case FIC_RGB:
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
PNG_COLOR_TYPE_RGB, interlace_type,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// flip BGR pixels to RGB
if(image_type == FIT_BITMAP)
png_set_bgr(png_ptr);
#endif
break;
case FIC_CMYK:
break;
}
// write possible ICC profile
FIICCPROFILE *iccProfile = FreeImage_GetICCProfile(dib);
if (iccProfile->size && iccProfile->data) {
png_set_iCCP(png_ptr, info_ptr, "Embedded Profile", 0, (png_charp)iccProfile->data, iccProfile->size);
}
// write metadata
WriteMetadata(png_ptr, info_ptr, dib);
// Optional gamma chunk is strongly suggested if you have any guess
// as to the correct gamma of the image.
// png_set_gAMA(png_ptr, info_ptr, gamma);
// set the transparency table
if (FreeImage_IsTransparent(dib) && (FreeImage_GetTransparencyCount(dib) > 0)) {
png_set_tRNS(png_ptr, info_ptr, FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib), NULL);
}
// set the background color
if(FreeImage_HasBackgroundColor(dib)) {
png_color_16 image_background;
RGBQUAD rgbBkColor;
FreeImage_GetBackgroundColor(dib, &rgbBkColor);
memset(&image_background, 0, sizeof(png_color_16));
image_background.blue = rgbBkColor.rgbBlue;
image_background.green = rgbBkColor.rgbGreen;
image_background.red = rgbBkColor.rgbRed;
image_background.index = rgbBkColor.rgbReserved;
png_set_bKGD(png_ptr, info_ptr, &image_background);
}
// Write the file header information.
png_write_info(png_ptr, info_ptr);
// write out the image data
#ifndef FREEIMAGE_BIGENDIAN
if (bit_depth == 16) {
// turn on 16 bit byte swapping
png_set_swap(png_ptr);
}
#endif
int number_passes = 1;
if (bInterlaced) {
number_passes = png_set_interlace_handling(png_ptr);
}
if ((pixel_depth == 32) && (!has_alpha_channel)) {
BYTE *buffer = (BYTE *)malloc(width * 3);
// transparent conversion to 24-bit
// the number of passes is either 1 for non-interlaced images, or 7 for interlaced images
for (int pass = 0; pass < number_passes; pass++) {
for (png_uint_32 k = 0; k < height; k++) {
FreeImage_ConvertLine32To24(buffer, FreeImage_GetScanLine(dib, height - k - 1), width);
png_write_row(png_ptr, buffer);
}
}
free(buffer);
} else {
// the number of passes is either 1 for non-interlaced images, or 7 for interlaced images
for (int pass = 0; pass < number_passes; pass++) {
for (png_uint_32 k = 0; k < height; k++) {
png_write_row(png_ptr, FreeImage_GetScanLine(dib, height - k - 1));
}
}
}
// It is REQUIRED to call this to finish writing the rest of the file
// Bug with png_flush
png_write_end(png_ptr, info_ptr);
// clean up after the write, and free any memory allocated
if (palette) {
png_free(png_ptr, palette);
}
png_destroy_write_struct(&png_ptr, &info_ptr);
return TRUE;
} catch (const char *text) {
FreeImage_OutputMessageProc(s_format_id, text);
}
}
return FALSE;
}
// ==========================================================
// Init
// ==========================================================
void DLL_CALLCONV
InitPNG(Plugin *plugin, int format_id) {
s_format_id = format_id;
plugin->format_proc = Format;
plugin->description_proc = Description;
plugin->extension_proc = Extension;
plugin->regexpr_proc = RegExpr;
plugin->open_proc = NULL;
plugin->close_proc = NULL;
plugin->pagecount_proc = NULL;
plugin->pagecapability_proc = NULL;
plugin->load_proc = Load;
plugin->save_proc = Save;
plugin->validate_proc = Validate;
plugin->mime_proc = MimeType;
plugin->supports_export_bpp_proc = SupportsExportDepth;
plugin->supports_export_type_proc = SupportsExportType;
plugin->supports_icc_profiles_proc = SupportsICCProfiles;
}
| 28.922574 | 116 | 0.669557 | sumneko |
b4de8f00ebe48a9ced52f6fa51080c759423ad08 | 1,461 | hpp | C++ | third_party/boost/simd/function/bitwise_and.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | 5 | 2018-02-20T11:21:12.000Z | 2019-11-12T13:45:09.000Z | third_party/boost/simd/function/bitwise_and.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | null | null | null | third_party/boost/simd/function/bitwise_and.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | 2 | 2017-12-12T12:29:52.000Z | 2019-04-08T15:55:25.000Z | //==================================================================================================
/*!
@file
@copyright 2016 NumScale SAS
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
//==================================================================================================
#ifndef BOOST_SIMD_FUNCTION_BITWISE_AND_HPP_INCLUDED
#define BOOST_SIMD_FUNCTION_BITWISE_AND_HPP_INCLUDED
#if defined(DOXYGEN_ONLY)
namespace boost { namespace simd
{
/*!
@ingroup group-bitwise
Function object implementing bitwise_and capabilities
Computes the bitwise and of the two parameters.
The operands must share the same bit size.
The result type is the one of the first operand.
Infix notation can be used with operator '&',
but this will not work in scalar mode if any
operand is floating point because of C++ limitations.
@par Semantic:
For every parameters of @c x of type @c T0, @c y of type @c T1:
@code
T0 r = bitwise_and(x,y);
@endcode
is similar to:
@code
T0 r = x & y;
@endcode
@see bitwise_or, bitwise_xor, bitwise_notand,
bitwise_andnot, bitwise_notor, bitwise_ornot, complement
**/
T0 bitwise_and(T0 const& x, T1 const& y);
} }
#endif
#include <boost/simd/function/scalar/bitwise_and.hpp>
#include <boost/simd/function/simd/bitwise_and.hpp>
#endif
| 24.762712 | 100 | 0.613963 | xmar |
b4e16904f5ba11c19ee99bfeb9e8205bcf639a10 | 728 | cc | C++ | cxx/satellite/src/SensitiveDetectorFactory.cc | Zelenyy/phd-code | d5b8bfefd2418a915dde89f7da2cb6683f438556 | [
"MIT"
] | null | null | null | cxx/satellite/src/SensitiveDetectorFactory.cc | Zelenyy/phd-code | d5b8bfefd2418a915dde89f7da2cb6683f438556 | [
"MIT"
] | null | null | null | cxx/satellite/src/SensitiveDetectorFactory.cc | Zelenyy/phd-code | d5b8bfefd2418a915dde89f7da2cb6683f438556 | [
"MIT"
] | null | null | null | //
// Created by zelenyy on 07.12.17.
//
#include "SensitiveDetectorFactory.hh"
#include "SensitiveScoredDetector.hh"
#include "G4SDManager.hh"
using namespace std;
G4VSensitiveDetector *SensitiveDetectorFactory::getSensitiveDetector(G4GDMLAuxListType::const_iterator vit) {
auto name = (*vit).value;
G4SDManager *fSDM = G4SDManager::GetSDMpointer();
G4VSensitiveDetector *tempDetector;
if (name == "SensitiveScoredDetector") {
tempDetector = new SensitiveScoredDetector(name, fSettings);
} else {
tempDetector = IDetectorFactory::getSensitiveDetector(vit);
}
fSDM->AddNewDetector(tempDetector);
G4cout << "Create new detector: " << name << endl;
return tempDetector;
}
| 26.962963 | 109 | 0.721154 | Zelenyy |
b4e2959d4569b3a2fe6e34d099433cc45686a1a4 | 924 | cpp | C++ | test/examples_test/02_module_test/02_module_tests.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-Ruby1909 | 3edea4f327aea2b8c9c7e788693339d1625a039f | [
"MIT"
] | null | null | null | test/examples_test/02_module_test/02_module_tests.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-Ruby1909 | 3edea4f327aea2b8c9c7e788693339d1625a039f | [
"MIT"
] | null | null | null | test/examples_test/02_module_test/02_module_tests.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-Ruby1909 | 3edea4f327aea2b8c9c7e788693339d1625a039f | [
"MIT"
] | null | null | null | #define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
#include "catch.hpp"
#include "if.h"
#include "if_else.h"
#include "switch.h"
TEST_CASE("Verify Test Configuration", "verification") {
REQUIRE(true == true);
}
TEST_CASE("Test is even function")
{
REQUIRE(is_even(2) == true);
}
TEST_CASE("Test get generation function")
{
REQUIRE(get_generation(2010) == "Centenial");
REQUIRE(get_generation(1990) == "Millenial");
REQUIRE(get_generation(1970) == "Generation X");
REQUIRE(get_generation(1950) == "Baby Boomer");
REQUIRE(get_generation(1930) == "Silent Generation");
//REQUIRE(get_generation(1000) == "Invalid Year");
}
TEST_CASE("Test menu function ")
{
REQUIRE(menu(0) == "Invalid Option");
REQUIRE(menu(1) == "Option 1");
REQUIRE(menu(2) == "Option 2");
REQUIRE(menu(3) == "Option 3");
REQUIRE(menu(4) == "Option 4");
REQUIRE(menu(5) == "Invalid Option");
} | 27.176471 | 97 | 0.685065 | acc-cosc-1337-spring-2020 |
b4e30396f958ebc6cf81d57b713635ac95a5406e | 2,658 | cpp | C++ | actions/SendMessageAction.cpp | horfee/alarmpi | e48e016d2378f0db0ef19abd47d144d0b1dbd904 | [
"Apache-2.0"
] | null | null | null | actions/SendMessageAction.cpp | horfee/alarmpi | e48e016d2378f0db0ef19abd47d144d0b1dbd904 | [
"Apache-2.0"
] | null | null | null | actions/SendMessageAction.cpp | horfee/alarmpi | e48e016d2378f0db0ef19abd47d144d0b1dbd904 | [
"Apache-2.0"
] | null | null | null | /*
* SendMessageAction.cpp
*
* Created on: 3 août 2015
* Author: horfee
*/
#include "SendMessageAction.h"
#include "../Properties.h"
#include <ctime>
#include <locale>
namespace alarmpi {
SendMessageAction::SendMessageAction(std::string name, std::string message, bool synchronous): Action(name, synchronous), message(message) {
}
SendMessageAction::~SendMessageAction() {
}
std::string SendMessageAction::getMessage() const {
return message;
}
void SendMessageAction::execute(Device* device, Mode* mode) {
// if ( !stopAsked() ) {
// setRunning();
size_t pos = message.find("$device");
std::string msg = message;
if ( pos != std::string::npos ) {
msg = message.substr(0, pos) + device->getDescription() + message.substr(pos + std::string("$device").length());
}
pos = msg.find("$mode");
if ( pos != std::string::npos ) {
msg = msg.substr(0, pos) + mode->getName() + msg.substr(pos + std::string("$mode").length());
}
pos = msg.find("$time");
if ( pos != std::string::npos ) {
std::time_t t = std::time(NULL);
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%X", std::localtime(&t));
msg = msg.substr(0, pos) + std::string(mbstr) + msg.substr(pos + std::string("$time").length());
}
pos = msg.find("$date");
if ( pos != std::string::npos ) {
std::time_t t = std::time(NULL);
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%x", std::localtime(&t));
msg = msg.substr(0, pos) + std::string(mbstr) + msg.substr(pos + std::string("$date").length());
}
pos = msg.find("$action.");
if ( pos != std::string::npos ) {
size_t pos2 = msg.find(" ", pos + 8);
std::string val = msg.substr(pos + 8, pos2 - (pos + 8));
Json::Value v = this->toJSON();
Json::Value v2 = v[val];
std::string res;
if ( v2.type() == Json::ValueType::stringValue ) {
res = v2.asString();
} else if ( v2.type() == Json::ValueType::intValue ) {
res = std::to_string(v2.asInt());
} else if ( v2.type() == Json::ValueType::realValue ) {
res = std::to_string(v2.asDouble());
} else if ( v2.type() == Json::ValueType::booleanValue ) {
res = std::to_string(v2.asBool());
} else if ( v2.type() == Json::ValueType::uintValue ) {
res = std::to_string(v2.asUInt());
}
msg = msg.substr(0, pos) + res + msg.substr(pos2);
}
// if ( !stopAsked() ) {
system->sendSMS(msg);
// }
// }
// Action::execute(device, mode);
}
Json::Value SendMessageAction::toJSON() const {
Json::Value res = Action::toJSON();
res["message"] = message;
return res;
}
std::string SendMessageAction::getType() const {
return "SENDMESSAGEACTION";
}
} /* namespace alarmpi */
| 29.208791 | 140 | 0.611362 | horfee |
b4e59b2d4ff7ae5363cb8830079782c204448464 | 7,679 | cpp | C++ | src/runtime_src/core/tools/common/XBMain.cpp | DavidMarec/XRT | 629f07123bff878a7916b82068b925acf5c4aa9c | [
"Apache-2.0"
] | null | null | null | src/runtime_src/core/tools/common/XBMain.cpp | DavidMarec/XRT | 629f07123bff878a7916b82068b925acf5c4aa9c | [
"Apache-2.0"
] | null | null | null | src/runtime_src/core/tools/common/XBMain.cpp | DavidMarec/XRT | 629f07123bff878a7916b82068b925acf5c4aa9c | [
"Apache-2.0"
] | null | null | null | /**
* Copyright (C) 2019-2022 Xilinx, Inc
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may
* not use this file except in compliance with the License. A copy of the
* License is located 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.
*/
// ------ I N C L U D E F I L E S -------------------------------------------
// Local - Include Files
#include "SubCmd.h"
#include "XBHelpMenusCore.h"
#include "XBUtilitiesCore.h"
#include "XBHelpMenus.h"
#include "XBMain.h"
#include "XBUtilities.h"
namespace XBU = XBUtilities;
// 3rd Party Library - Include Files
#include <boost/filesystem.hpp>
#include <boost/format.hpp>
#include <boost/program_options.hpp>
#include <cstdlib>
namespace po = boost::program_options;
// System - Include Files
#include <iostream>
// ------ Program entry point -------------------------------------------------
void main_(int argc, char** argv,
const std::string & _executable,
const std::string & _description,
const SubCmdsCollection &_subCmds)
{
bool isUserDomain = boost::iequals(_executable, "xbutil");
// Global options
bool bVerbose = false;
bool bTrace = false;
bool bHelp = false;
bool bBatchMode = false;
bool bShowHidden = false;
bool bForce = false;
bool bVersion = false;
std::string sDevice;
// Build Options
po::options_description globalSubCmdOptions("Global Command Options");
globalSubCmdOptions.add_options()
("verbose", boost::program_options::bool_switch(&bVerbose), "Turn on verbosity")
("batch", boost::program_options::bool_switch(&bBatchMode), "Enable batch mode (disables escape characters)")
("force", boost::program_options::bool_switch(&bForce), "When possible, force an operation")
;
po::options_description globalOptions("Global Options");
globalOptions.add_options()
("help", boost::program_options::bool_switch(&bHelp), "Help to use this application")
("version", boost::program_options::bool_switch(&bVersion), "Report the version of XRT and its drivers")
;
globalOptions.add(globalSubCmdOptions);
// Hidden Options
po::options_description hiddenOptions("Hidden Options");
hiddenOptions.add_options()
("device,d", boost::program_options::value<decltype(sDevice)>(&sDevice)->default_value("")->implicit_value("default"), "If specified with no BDF value and there is only 1 device, that device will be automatically selected.\n")
("trace", boost::program_options::bool_switch(&bTrace), "Enables code flow tracing")
("show-hidden", boost::program_options::bool_switch(&bShowHidden), "Shows hidden options and commands")
("subCmd", po::value<std::string>(), "Command to execute")
("subCmdArgs", po::value<std::vector<std::string> >(), "Arguments for command")
;
// Merge the options to one common collection
po::options_description allOptions("All Options");
allOptions.add(globalOptions).add(hiddenOptions);
// Create a sub-option command and arguments
po::positional_options_description positionalCommand;
positionalCommand.
add("subCmd", 1 /* max_count */).
add("subCmdArgs", -1 /* Unlimited max_count */);
// -- Parse the command line
po::parsed_options parsed = po::command_line_parser(argc, argv).
options(allOptions). // Global options
positional(positionalCommand). // Our commands
allow_unregistered(). // Allow for unregistered options (needed for sub options)
run(); // Parse the options
po::variables_map vm;
try {
po::store(parsed, vm); // Can throw
po::notify(vm); // Can throw
} catch (po::error& e) {
// Something bad happen with parsing our options
std::cerr << "ERROR: " << e.what() << std::endl << std::endl;
XBU::report_commands_help(_executable, _description, globalOptions, hiddenOptions, _subCmds);
throw xrt_core::error(std::errc::operation_canceled);
}
if(bVersion) {
std::cout << XBU::get_xrt_pretty_version();
return;
}
// -- Enable/Disable helper "global" options
XBU::disable_escape_codes( bBatchMode );
XBU::setVerbose( bVerbose );
XBU::setTrace( bTrace );
XBU::setShowHidden( bShowHidden );
XBU::setForce( bForce );
// Check to see if help was requested and no command was found
if (vm.count("subCmd") == 0) {
XBU::report_commands_help( _executable, _description, globalOptions, hiddenOptions, _subCmds);
return;
}
// -- Now see if there is a command to work with
// Get the command of choice
std::string sCommand = vm["subCmd"].as<std::string>();
// Search for the subcommand (case sensitive)
std::shared_ptr<SubCmd> subCommand;
for (auto & subCmdEntry : _subCmds) {
if (sCommand.compare(subCmdEntry->getName()) == 0) {
subCommand = subCmdEntry;
break;
}
}
if ( !subCommand) {
std::cerr << "ERROR: " << "Unknown command: '" << sCommand << "'" << std::endl;
XBU::report_commands_help( _executable, _description, globalOptions, hiddenOptions, _subCmds);
throw xrt_core::error(std::errc::operation_canceled);
}
// -- Prepare the data
std::vector<std::string> opts = po::collect_unrecognized(parsed.options, po::include_positional);
opts.erase(opts.begin());
if (bHelp == true)
opts.push_back("--help");
#ifdef ENABLE_DEFAULT_ONE_DEVICE_OPTION
// If the user has NOT specified a device AND the command to be executed
// is not the examine command, then automatically add the device.
// Note: "examine" produces different reports depending if the user has
// specified the --device option or not.
if ( sDevice.empty() &&
(subCommand->isDefaultDeviceValid())) {
sDevice = "default";
}
#endif
// Was default device requested?
if (boost::iequals(sDevice, "default")) {
sDevice.clear();
boost::property_tree::ptree available_devices = XBU::get_available_devices(isUserDomain);
// DRC: Are there any devices
if (available_devices.empty())
throw std::runtime_error("No devices found.");
// DRC: Are there multiple devices, if so then no default device can be found.
if (available_devices.size() > 1) {
std::cerr << "\nERROR: Multiple devices found. Please specify a single device using the --device option\n\n";
std::cerr << "List of available devices:" << std::endl;
for (auto &kd : available_devices) {
boost::property_tree::ptree& dev = kd.second;
std::cerr << boost::format(" [%s] : %s\n") % dev.get<std::string>("bdf") % dev.get<std::string>("vbnv");
}
std::cout << std::endl;
throw xrt_core::error(std::errc::operation_canceled);
}
// We have only 1 item in the array, get it
for (const auto &kd : available_devices)
sDevice = kd.second.get<std::string>("bdf"); // Exit after the first item
}
// If there is a device value, pass it to the sub commands.
if (!sDevice.empty()) {
opts.push_back("-d");
opts.push_back(sDevice);
}
subCommand->setGlobalOptions(globalSubCmdOptions);
// -- Execute the sub-command
subCommand->execute(opts);
}
| 37.096618 | 234 | 0.650345 | DavidMarec |
b4e868e08e9d479d724d5eff05c4abb63dbde16f | 569 | cpp | C++ | cpp/optimizers/ut/optimizer_ut.cpp | equivalence1/ml_lib | 92d75ab73bc2d77ba8fa66022c803c06cad66f21 | [
"Apache-2.0"
] | 1 | 2019-02-15T09:40:43.000Z | 2019-02-15T09:40:43.000Z | cpp/optimizers/ut/optimizer_ut.cpp | equivalence1/ml_lib | 92d75ab73bc2d77ba8fa66022c803c06cad66f21 | [
"Apache-2.0"
] | null | null | null | cpp/optimizers/ut/optimizer_ut.cpp | equivalence1/ml_lib | 92d75ab73bc2d77ba8fa66022c803c06cad66f21 | [
"Apache-2.0"
] | 2 | 2018-09-29T10:17:26.000Z | 2018-10-03T20:33:31.000Z | #include <core/vec_factory.h>
#include <core/optimizers/gradient_descent.h>
#include <core/vec_tools/fill.h>
#include <core/vec_tools/distance.h>
#include <core/funcs/lq.h>
#include <gtest/gtest.h>
TEST(Optimizer, GradientDescentTest) {
const int N = 10;
const double q = 2;
const double EPS = 0.01;
GradientDescent gd(EPS);
auto cursor = Vec(N);
VecTools::fill(1, cursor);
auto b = Vec(N);
VecTools::fill(2, b);
Lq distFunc(q, b);
gd.optimize(distFunc, cursor);
EXPECT_LE(VecTools::distanceLq(q, cursor, b), EPS);
}
| 20.321429 | 55 | 0.659051 | equivalence1 |
b4edd9903a9b291dca0cc419439d573b9a957efb | 5,512 | cpp | C++ | Desktop/Lib/CCore/src/video/lib/Shape.FixedFrame.cpp | SergeyStrukov/CCore-3-xx | 820507e78f8aa35ca05761e00e060c8f64c59af5 | [
"BSL-1.0"
] | 8 | 2017-12-21T07:00:16.000Z | 2020-04-02T09:05:55.000Z | Desktop/Lib/CCore/src/video/lib/Shape.FixedFrame.cpp | SergeyStrukov/CCore-3-xx | 820507e78f8aa35ca05761e00e060c8f64c59af5 | [
"BSL-1.0"
] | null | null | null | Desktop/Lib/CCore/src/video/lib/Shape.FixedFrame.cpp | SergeyStrukov/CCore-3-xx | 820507e78f8aa35ca05761e00e060c8f64c59af5 | [
"BSL-1.0"
] | 1 | 2020-03-30T09:54:18.000Z | 2020-03-30T09:54:18.000Z | /* Shape.FixedFrame.cpp */
//----------------------------------------------------------------------------------------
//
// Project: CCore 3.50
//
// Tag: Desktop
//
// License: Boost Software License - Version 1.0 - August 17th, 2003
//
// see http://www.boost.org/LICENSE_1_0.txt or the local copy
//
// Copyright (c) 2017 Sergey Strukov. All rights reserved.
//
//----------------------------------------------------------------------------------------
#include <CCore/inc/video/lib/Shape.FixedFrame.h>
namespace CCore {
namespace Video {
/* class FixedFrameShape */
void FixedFrameShape::draw_Frame(const DrawBuf &buf,Pane part) const
{
VColor frame=+cfg.frame;
VColor small=+cfg.dragSmall;
VColor frameSmall = has_good_size? frame : small ;
if( hilight==DragType_Bar ) frameSmall=frame=+cfg.frameHilight;
if( drag_type==DragType_Bar ) frameSmall=frame=+cfg.frameDrag;
drawFrame(buf,Pane(Null,size),client,frame,frameSmall,part);
}
void FixedFrameShape::draw_Frame(const DrawBuf &buf) const
{
draw_Frame(buf,Pane(Null,size));
}
void FixedFrameShape::draw_Frame(const DrawBuf &buf,DragType drag_type) const
{
Pane part=getPane(drag_type);
draw_Frame(buf.cut(part),part);
}
void FixedFrameShape::draw_Bar(const DrawBuf &buf) const
{
drawBar(buf,titleBar);
}
void FixedFrameShape::draw_Alert(const DrawBuf &buf) const
{
drawAlert(buf,btnAlert);
}
void FixedFrameShape::draw_Help(const DrawBuf &buf) const
{
drawHelp(buf,btnHelp);
}
void FixedFrameShape::draw_Min(const DrawBuf &buf) const
{
drawMin(buf,btnMin);
}
void FixedFrameShape::draw_Close(const DrawBuf &buf) const
{
drawClose(buf,btnClose);
}
void FixedFrameShape::layout(Point size_)
{
size=size_;
Coord dxy=+cfg.frame_dxy;
Coord tdy=+cfg.title_dy;
Coord bdx=+cfg.btn_dx;
Coord bdy=+cfg.btn_dy;
Coord btn_len = is_main? 5*bdx : 3*bdx ;
if( size>Point( 2*dxy+btn_len+bdx/2+Max(tdy,dxy) , dxy+Max(tdy,dxy) ) )
{
Pane pane=Pane(Null,size);
SplitX(dxy,pane);
SplitX(pane,dxy);
Pane top=SplitY(tdy,pane);
SplitY(pane,dxy);
client=pane;
Coord yb=(tdy-bdy)/2;
Coord tx=top.dx-btn_len;
if( is_main )
{
Coord xb0=top.x+tx;
Coord xb1=xb0+bdx+bdx/8;
Coord xb2=xb1+bdx+bdx/8;
Coord xb3=xb2+bdx+bdx/2;
btnAlert=Pane(xb0,yb,bdx,bdy);
btnHelp=Pane(xb1,yb,bdx,bdy);
btnMin=Pane(xb2,yb,bdx,bdy);
btnClose=Pane(xb3,yb,bdx,bdy);
}
else
{
Coord xb0=top.x+tx;
Coord xb1=xb0+bdx+bdx/2;
btnAlert=Empty;
btnMin=Empty;
btnHelp=Pane(xb0,yb,bdx,bdy);
btnClose=Pane(xb1,yb,bdx,bdy);
}
Coord w=cfg.width.get().roundUp();
titleBar=Pane(top.x+bdx/4,w,tx-bdx/2,tdy-2*w);
}
else
{
client=Empty;
btnAlert=Empty;
btnHelp=Empty;
btnMin=Empty;
btnClose=Pane(Null,bdx,bdy);
titleBar=Empty;
}
}
Point FixedFrameShape::getDeltaSize() const
{
Coord dxy=+cfg.frame_dxy;
Coord tdy=+cfg.title_dy;
return Point(dxy,tdy)+Point(dxy,dxy);
}
Coord FixedFrameShape::getMinDX(bool is_main,StrLen title) const
{
Coord width=cfg.width.get().roundUp();
Coord tdy=+cfg.title_dy;
Coord dxy=+cfg.frame_dxy;
Coord bdx=+cfg.btn_dx;
Coord btn_len = is_main? 5*bdx : 3*bdx ;
Coord dx=getMinTitleDX(title,tdy-2*width);
Replace_max(dx,Max(tdy,dxy));
dx += 2*dxy+btn_len+bdx/2 ;
return dx;
}
DragType FixedFrameShape::dragTest(Point point) const
{
if( btnAlert.contains(point) ) return DragType_Alert;
if( btnHelp.contains(point) ) return DragType_Help;
if( btnMin.contains(point) ) return DragType_Min;
if( btnClose.contains(point) ) return DragType_Close;
return client.contains(point)?DragType_None:DragType_Bar;
}
Pane FixedFrameShape::getPane(DragType drag_type) const
{
switch( drag_type )
{
case DragType_Bar : return Pane(Null,size);
case DragType_Alert : return btnAlert;
case DragType_Help : return btnHelp;
case DragType_Min : return btnMin;
case DragType_Close : return btnClose;
default: return Empty;
}
}
Hint FixedFrameShape::getHint(Point point) const
{
switch( dragTest(point) )
{
case DragType_Alert : return {btnAlert,+cfg.hint_Alert};
case DragType_Help : return {btnHelp,+cfg.hint_Help};
case DragType_Min : return {btnMin,+cfg.hint_Minimize};
case DragType_Close : return {btnClose,+cfg.hint_Close};
default: return Null;
}
}
void FixedFrameShape::draw(const DrawBuf &buf) const
{
draw_Frame(buf);
draw_Bar(buf);
draw_Alert(buf);
draw_Help(buf);
draw_Min(buf);
draw_Close(buf);
}
void FixedFrameShape::draw(const DrawBuf &buf,DragType drag_type) const
{
if( drag_type==DragType_Bar )
{
draw_Frame(buf);
draw_Bar(buf);
draw_Alert(buf);
draw_Help(buf);
draw_Min(buf);
draw_Close(buf);
}
else
{
draw_Frame(buf,drag_type);
switch( drag_type )
{
case DragType_Alert : draw_Alert(buf); break;
case DragType_Help : draw_Help(buf); break;
case DragType_Min : draw_Min(buf); break;
case DragType_Close : draw_Close(buf); break;
}
}
}
void FixedFrameShape::drawHint(const DrawBuf &buf,Hint hint) const
{
FrameShapeBase::drawHint(buf,titleBar,hint);
}
} // namespace Video
} // namespace CCore
| 21.53125 | 90 | 0.630987 | SergeyStrukov |
b4eef0fcf4c0c5747f617ca484bff6622669060b | 11,488 | cc | C++ | algorithms/loopclosure/inverted-multi-index/test/test_inverted-multi-index.cc | AdronTech/maplab | 1340e01466fc1c02994860723b8117daf9ad226d | [
"Apache-2.0"
] | 1,936 | 2017-11-27T23:11:37.000Z | 2022-03-30T14:24:14.000Z | algorithms/loopclosure/inverted-multi-index/test/test_inverted-multi-index.cc | AdronTech/maplab | 1340e01466fc1c02994860723b8117daf9ad226d | [
"Apache-2.0"
] | 353 | 2017-11-29T18:40:39.000Z | 2022-03-30T15:53:46.000Z | algorithms/loopclosure/inverted-multi-index/test/test_inverted-multi-index.cc | AdronTech/maplab | 1340e01466fc1c02994860723b8117daf9ad226d | [
"Apache-2.0"
] | 661 | 2017-11-28T07:20:08.000Z | 2022-03-28T08:06:29.000Z | #include <utility>
#include <vector>
#include <Eigen/Core>
#include <aslam/common/memory.h>
#include <maplab-common/test/testing-entrypoint.h>
#include <maplab-common/test/testing-predicates.h>
#include <inverted-multi-index/inverted-multi-index-common.h>
#include <inverted-multi-index/inverted-multi-index.h>
namespace loop_closure {
namespace inverted_multi_index {
namespace {
class TestableInvertedMultiIndex : public InvertedMultiIndex<3> {
public:
TestableInvertedMultiIndex(
const Eigen::MatrixXf& words1, const Eigen::MatrixXf& words2,
int num_closest_words_for_nn_search)
: InvertedMultiIndex<3>(words1, words2, num_closest_words_for_nn_search) {
}
using InvertedMultiIndex<3>::words_1_index_;
using InvertedMultiIndex<3>::words_2_index_;
using InvertedMultiIndex<3>::word_index_map_;
using InvertedMultiIndex<3>::inverted_files_;
using InvertedMultiIndex<3>::max_db_descriptor_index_;
};
class InvertedMultiIndexTest : public ::testing::Test {
public:
void SetUp() {
words1_.resize(3, 10);
words1_ << 0.751267059305653, 0.547215529963803, 0.814284826068816,
0.616044676146639, 0.917193663829810, 0.075854289563064,
0.568823660872193, 0.311215042044805, 0.689214503140008,
0.152378018969223, 0.255095115459269, 0.138624442828679,
0.243524968724989, 0.473288848902729, 0.285839018820374,
0.053950118666607, 0.469390641058206, 0.528533135506213,
0.748151592823709, 0.825816977489547, 0.505957051665142,
0.149294005559057, 0.929263623187228, 0.351659507062997,
0.757200229110721, 0.530797553008973, 0.011902069501241,
0.165648729499781, 0.450541598502498, 0.538342435260057;
words2_.resize(3, 5);
words2_ << 0.699076722656686, 0.257508254123736, 0.349983765984809,
0.830828627896291, 0.753729094278495, 0.890903252535798,
0.840717255983663, 0.196595250431208, 0.585264091152724,
0.380445846975357, 0.959291425205444, 0.254282178971531,
0.251083857976031, 0.549723608291140, 0.567821640725221;
}
Eigen::MatrixXf words1_;
Eigen::MatrixXf words2_;
};
TEST_F(InvertedMultiIndexTest, AddDescriptorsWorks) {
// FLAG used to control the amount of backtracking done during kd-tree-based
// nearest neighbor search. In order to work, this test needs a certain amount
// of backtracking.
FLAGS_lc_knn_epsilon = 0.2;
Eigen::MatrixXf descriptors(6, 50);
descriptors << 0.837, 0.298, 0.071, 0.971, 0.205, 0.170, 0.236, 0.043, 0.087,
0.638, 0.583, 0.727, 0.013, 0.741, 0.088, 0.465, 0.514, 0.948, 0.552,
0.118, 0.018, 0.719, 0.482, 0.343, 0.599, 0.984, 0.455, 0.568, 0.576,
0.678, 0.370, 0.506, 0.600, 0.867, 0.888, 0.520, 0.736, 0.227, 0.072,
0.176, 0.858, 0.497, 0.403, 0.861, 0.921, 0.425, 0.671, 0.998, 0.903,
0.938, 0.930, 0.721, 0.448, 0.799, 0.284, 0.239, 0.616, 0.298, 0.906,
0.573, 0.741, 0.156, 0.148, 0.379, 0.706, 0.703, 0.355, 0.351, 0.068,
0.969, 0.354, 0.875, 0.930, 0.869, 0.565, 0.213, 0.309, 0.106, 0.854,
0.163, 0.677, 0.443, 0.087, 0.276, 0.981, 0.792, 0.251, 0.918, 0.980,
0.026, 0.769, 0.473, 0.339, 0.565, 0.326, 0.986, 0.031, 0.662, 0.249,
0.035, 0.886, 0.901, 0.071, 0.524, 0.733, 0.091, 0.311, 0.473, 0.904,
0.531, 0.526, 0.849, 0.618, 0.361, 0.899, 0.763, 0.485, 0.668, 0.575,
0.861, 0.633, 0.427, 0.447, 0.930, 0.124, 0.250, 0.713, 0.405, 0.029,
0.250, 0.432, 0.096, 0.117, 0.666, 0.898, 0.608, 0.097, 0.468, 0.062,
0.943, 0.889, 0.583, 0.268, 0.101, 0.953, 0.780, 0.558, 0.219, 0.034,
0.378, 0.765, 0.044, 0.904, 0.320, 0.570, 0.855, 0.452, 0.344, 0.235,
0.919, 0.958, 0.052, 0.934, 0.927, 0.830, 0.992, 0.711, 0.888, 0.199,
0.056, 0.362, 0.465, 0.311, 0.337, 0.567, 0.951, 0.908, 0.336, 0.734,
0.975, 0.654, 0.448, 0.991, 0.075, 0.128, 0.767, 0.775, 0.565, 0.282,
0.388, 0.698, 0.721, 0.439, 0.631, 0.733, 0.555, 0.991, 0.568, 0.137,
0.178, 0.608, 0.342, 0.451, 0.838, 0.624, 0.879, 0.163, 0.829, 0.508,
0.016, 0.986, 0.644, 0.639, 0.408, 0.485, 0.720, 0.818, 0.689, 0.518,
0.810, 0.513, 0.134, 0.244, 0.271, 0.473, 0.743, 0.445, 0.259, 0.231,
0.772, 0.679, 0.817, 0.654, 0.055, 0.155, 0.941, 0.707, 0.637, 0.460,
0.132, 0.651, 0.524, 0.103, 0.482, 0.090, 0.633, 0.265, 0.352, 0.250,
0.035, 0.748, 0.238, 0.528, 0.061, 0.257, 0.691, 0.227, 0.143, 0.551,
0.207, 0.798, 0.442, 0.920, 0.016, 0.275, 0.457, 0.737, 0.763, 0.951,
0.274, 0.999, 0.092, 0.940, 0.526, 0.270, 0.512, 0.774, 0.466, 0.781,
0.848, 0.947, 0.413, 0.636, 0.867, 0.813, 0.664, 0.702, 0.687, 0.818,
0.825, 0.437, 0.302, 0.145, 0.855, 0.363, 0.091, 0.329, 0.044, 0.380,
0.876;
std::vector<int> nearest_word_per_descriptor = {
43, 47, 38, 41, 26, 35, 37, 26, 46, 44, 40, 11, 25, 18, 48, 43, 15,
23, 0, 46, 25, 42, 44, 47, 32, 3, 4, 2, 34, 5, 45, 31, 8, 22,
42, 40, 8, 48, 49, 29, 43, 18, 37, 34, 14, 46, 4, 42, 7, 2};
std::vector<bool> word_used(50, false);
std::vector<int> word_index(50, -1);
int counter = 0;
for (int i = 0; i < 50; ++i) {
if (!word_used[nearest_word_per_descriptor[i]]) {
word_index[nearest_word_per_descriptor[i]] = counter;
word_used[nearest_word_per_descriptor[i]] = true;
++counter;
}
}
TestableInvertedMultiIndex index(words1_, words2_, 10);
index.AddDescriptors(descriptors);
ASSERT_EQ(50, index.max_db_descriptor_index_);
ASSERT_EQ(32u, index.word_index_map_.size());
ASSERT_EQ(32u, index.inverted_files_.size());
// Ensures that every descriptor is stored in its correct place.
std::vector<int> word_counts(50, 0);
for (int i = 0; i < 50; ++i) {
int word = word_index[nearest_word_per_descriptor[i]];
ASSERT_GE(word, 0);
ASSERT_LT(word, 32);
ASSERT_EQ(
index.inverted_files_[word].descriptors_.size(),
index.inverted_files_[word].indices_.size());
ASSERT_GE(
static_cast<int>(index.inverted_files_[word].descriptors_.size()),
word_counts[word]);
EXPECT_EQ(index.inverted_files_[word].indices_[word_counts[word]], i);
EXPECT_NEAR_EIGEN(
index.inverted_files_[word].descriptors_[word_counts[word]],
descriptors.col(i), 1e-12);
word_counts[word] += 1;
}
index.Clear();
EXPECT_EQ(0, index.max_db_descriptor_index_);
}
TEST_F(InvertedMultiIndexTest, GetNNearestNeighborsWorks) {
Eigen::MatrixXf descriptors(6, 50);
descriptors << 0.837, 0.298, 0.071, 0.971, 0.205, 0.170, 0.236, 0.043, 0.087,
0.638, 0.583, 0.727, 0.013, 0.741, 0.088, 0.465, 0.514, 0.948, 0.552,
0.118, 0.018, 0.719, 0.482, 0.343, 0.599, 0.984, 0.455, 0.568, 0.576,
0.678, 0.370, 0.506, 0.600, 0.867, 0.888, 0.520, 0.736, 0.227, 0.072,
0.176, 0.858, 0.497, 0.403, 0.861, 0.921, 0.425, 0.671, 0.998, 0.903,
0.938, 0.930, 0.721, 0.448, 0.799, 0.284, 0.239, 0.616, 0.298, 0.906,
0.573, 0.741, 0.156, 0.148, 0.379, 0.706, 0.703, 0.355, 0.351, 0.068,
0.969, 0.354, 0.875, 0.930, 0.869, 0.565, 0.213, 0.309, 0.106, 0.854,
0.163, 0.677, 0.443, 0.087, 0.276, 0.981, 0.792, 0.251, 0.918, 0.980,
0.026, 0.769, 0.473, 0.339, 0.565, 0.326, 0.986, 0.031, 0.662, 0.249,
0.035, 0.886, 0.901, 0.071, 0.524, 0.733, 0.091, 0.311, 0.473, 0.904,
0.531, 0.526, 0.849, 0.618, 0.361, 0.899, 0.763, 0.485, 0.668, 0.575,
0.861, 0.633, 0.427, 0.447, 0.930, 0.124, 0.250, 0.713, 0.405, 0.029,
0.250, 0.432, 0.096, 0.117, 0.666, 0.898, 0.608, 0.097, 0.468, 0.062,
0.943, 0.889, 0.583, 0.268, 0.101, 0.953, 0.780, 0.558, 0.219, 0.034,
0.378, 0.765, 0.044, 0.904, 0.320, 0.570, 0.855, 0.452, 0.344, 0.235,
0.919, 0.958, 0.052, 0.934, 0.927, 0.830, 0.992, 0.711, 0.888, 0.199,
0.056, 0.362, 0.465, 0.311, 0.337, 0.567, 0.951, 0.908, 0.336, 0.734,
0.975, 0.654, 0.448, 0.991, 0.075, 0.128, 0.767, 0.775, 0.565, 0.282,
0.388, 0.698, 0.721, 0.439, 0.631, 0.733, 0.555, 0.991, 0.568, 0.137,
0.178, 0.608, 0.342, 0.451, 0.838, 0.624, 0.879, 0.163, 0.829, 0.508,
0.016, 0.986, 0.644, 0.639, 0.408, 0.485, 0.720, 0.818, 0.689, 0.518,
0.810, 0.513, 0.134, 0.244, 0.271, 0.473, 0.743, 0.445, 0.259, 0.231,
0.772, 0.679, 0.817, 0.654, 0.055, 0.155, 0.941, 0.707, 0.637, 0.460,
0.132, 0.651, 0.524, 0.103, 0.482, 0.090, 0.633, 0.265, 0.352, 0.250,
0.035, 0.748, 0.238, 0.528, 0.061, 0.257, 0.691, 0.227, 0.143, 0.551,
0.207, 0.798, 0.442, 0.920, 0.016, 0.275, 0.457, 0.737, 0.763, 0.951,
0.274, 0.999, 0.092, 0.940, 0.526, 0.270, 0.512, 0.774, 0.466, 0.781,
0.848, 0.947, 0.413, 0.636, 0.867, 0.813, 0.664, 0.702, 0.687, 0.818,
0.825, 0.437, 0.302, 0.145, 0.855, 0.363, 0.091, 0.329, 0.044, 0.380,
0.876;
std::vector<int> nearest_word_per_descriptor = {
43, 47, 38, 41, 26, 35, 37, 26, 46, 44, 40, 11, 25, 18, 48, 43, 15,
23, 0, 46, 25, 42, 44, 47, 32, 3, 4, 2, 34, 5, 45, 31, 8, 22,
42, 40, 8, 48, 49, 29, 43, 18, 37, 34, 14, 46, 4, 42, 7, 2};
Eigen::MatrixXf query_descriptors(6, 10);
query_descriptors << 0.971, 0.890, 0.610, 0.509, 0.017, 0.922, 0.901, 0.323,
0.321, 0.745, 0.581, 0.179, 0.900, 0.622, 0.827, 0.945, 0.020, 0.921,
0.409, 0.737, 0.369, 0.800, 0.027, 0.497, 0.493, 0.556, 0.168, 0.705,
0.107, 0.012, 0.913, 0.912, 0.232, 0.611, 0.513, 0.625, 0.543, 0.639,
0.716, 0.584, 0.638, 0.791, 0.944, 0.111, 0.226, 0.626, 0.105, 0.086,
0.834, 0.696, 0.470, 0.813, 0.640, 0.236, 0.182, 0.292, 0.039, 0.230,
0.707, 0.006;
TestableInvertedMultiIndex index(words1_, words2_, 10);
index.AddDescriptors(descriptors);
for (int i = 0; i < 10; ++i) {
std::vector<std::pair<int, int> > ten_closest_words;
common::FindClosestWords<3>(
query_descriptors.col(i), 10, *(index.words_1_index_),
*(index.words_2_index_), words1_.cols(), words2_.cols(),
&ten_closest_words);
std::vector<bool> word_activated(50, 0);
for (int j = 0; j < 10; ++j) {
int word_index = ten_closest_words[j].first * words2_.cols() +
ten_closest_words[j].second;
word_activated[word_index] = true;
}
static constexpr int kNumNeighbors = 10;
Eigen::VectorXi indices(kNumNeighbors, 1);
Eigen::VectorXf distances(kNumNeighbors, 1);
index.GetNNearestNeighbors(
query_descriptors.block<6, 1>(0, i), kNumNeighbors, indices, distances);
// Verifies that the nearest neighbors are correct through linear search.
std::vector<std::pair<float, int> > gt_distances;
int num_neighbors = 0;
for (int j = 0; j < 50; ++j) {
if (!word_activated[nearest_word_per_descriptor[j]])
continue;
float d = (descriptors.col(j) - query_descriptors.col(i)).squaredNorm();
gt_distances.push_back(std::make_pair(d, j));
++num_neighbors;
}
std::sort(gt_distances.begin(), gt_distances.end());
Eigen::VectorXi expected_indices(kNumNeighbors, 1);
int num_elements = std::min(kNumNeighbors, num_neighbors);
for (int j = 0; j < num_elements; ++j) {
EXPECT_FLOAT_EQ(gt_distances[j].first, distances[j]);
expected_indices(j, 0) = gt_distances[j].second;
}
EXPECT_TRUE(
::common::MatricesEqual(
indices.block(0, 0, num_elements, 1),
expected_indices.block(0, 0, num_elements, 1), 1e-9));
}
}
} // namespace
} // namespace inverted_multi_index
} // namespace loop_closure
MAPLAB_UNITTEST_ENTRYPOINT
| 48.677966 | 80 | 0.616382 | AdronTech |
b4f0464df70ec90e1830f970cde7a89b2b9bf6db | 10,795 | cpp | C++ | example/oglplus/026_stencil_shadow.cpp | Extrunder/oglplus | c7c8266a1571d0b4c8b02d9c8ca6a7b6a6f51791 | [
"BSL-1.0"
] | null | null | null | example/oglplus/026_stencil_shadow.cpp | Extrunder/oglplus | c7c8266a1571d0b4c8b02d9c8ca6a7b6a6f51791 | [
"BSL-1.0"
] | null | null | null | example/oglplus/026_stencil_shadow.cpp | Extrunder/oglplus | c7c8266a1571d0b4c8b02d9c8ca6a7b6a6f51791 | [
"BSL-1.0"
] | null | null | null | /**
* @example oglplus/026_stencil_shadow.cpp
* @brief Shows how to render shadows using geometry shader and stencil buffer
*
* @oglplus_screenshot{026_stencil_shadow}
*
* Copyright 2008-2015 Matus Chochlik. Distributed under the Boost
* Software License, Version 1.0. (See accompanying file
* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*
* @oglplus_example_uses_gl{GL_VERSION_3_3}
* @oglplus_example_uses_gl{GL_ARB_separate_shader_objects;GL_EXT_direct_state_access}
*/
#include <oglplus/gl.hpp>
#include <oglplus/all.hpp>
#include <oglplus/shapes/torus.hpp>
#include <cmath>
#include "example.hpp"
namespace oglplus {
class ShadowExample : public Example
{
private:
// the torus vertex attribute builder
shapes::Torus make_torus;
// here will be stored the indices used by the drawing instructions
shapes::Torus::IndexArray torus_indices;
// the instructions for drawing the torus
shapes::DrawingInstructions torus_instr;
// wrapper around the current OpenGL context
Context gl;
// Shaders and program for rendering of the objects
VertexShader vs_object;
FragmentShader fs_object;
Program object_prog;
// Shaders and program for rendering of the shadow effect
VertexShader vs_shadow;
GeometryShader gs_shadow;
FragmentShader fs_shadow;
Program shadow_prog;
// Uniforms
Uniform<Mat4f>
object_projection_matrix, object_camera_matrix, object_model_matrix,
shadow_projection_matrix, shadow_camera_matrix, shadow_model_matrix;
Uniform<Vec3f> object_color;
Uniform<GLfloat> object_light_mult;
// A vertex array object for the torus
VertexArray torus;
// VBOs for the torus' vertices and normals
Buffer torus_verts, torus_normals;
// A vertex array object for the shadowed plane
VertexArray plane;
// VBOs for the plane's vertices and normals
Buffer plane_verts, plane_normals;
public:
ShadowExample(void)
: make_torus(1.0, 0.7, 72, 48)
, torus_indices(make_torus.Indices())
, torus_instr(make_torus.Instructions())
, object_projection_matrix(object_prog)
, object_camera_matrix(object_prog)
, object_model_matrix(object_prog)
, shadow_projection_matrix(shadow_prog)
, shadow_camera_matrix(shadow_prog)
, shadow_model_matrix(shadow_prog)
, object_color(object_prog)
, object_light_mult(object_prog)
{
vs_object.Source(
"#version 140\n"
"in vec4 Position;"
"in vec3 Normal;"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform vec3 LightPos;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos - gl_Position.xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
vs_object.Compile();
fs_object.Source(
"#version 140\n"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"uniform vec3 Color;"
"uniform float LightMult;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = sqrt(length(vertLight));"
" float d = l > 0.0 ?"
" dot("
" vertNormal,"
" normalize(vertLight)"
" ) / l : 0.0;"
" float i = 0.3 + max(d, 0.0) * LightMult;"
" fragColor = vec4(Color*i, 1.0);"
"}"
);
fs_object.Compile();
object_prog.AttachShader(vs_object);
object_prog.AttachShader(fs_object);
object_prog.Link().Use();
object_projection_matrix.BindTo("ProjectionMatrix");
object_camera_matrix.BindTo("CameraMatrix");
object_model_matrix.BindTo("ModelMatrix");
object_color.BindTo("Color");
object_light_mult.BindTo("LightMult");
vs_shadow.Source(
"#version 150\n"
"in vec4 Position;"
"in vec3 Normal;"
"uniform mat4 ModelMatrix;"
"uniform vec3 LightPos;"
"out float ld;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vec3 geomNormal = mat3(ModelMatrix)*Normal;"
" vec3 lightDir = LightPos - gl_Position.xyz;"
" ld = dot(geomNormal, normalize(lightDir));"
"}"
);
vs_shadow.Compile();
gs_shadow.Source(
"#version 150\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 12) out;"
"in float ld[];"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" for(int v=0; v!=3; ++v)"
" {"
" int a = v, b = (v+1)%3, c = (v+2)%3;"
" vec4 pa = gl_in[a].gl_Position;"
" vec4 pb = gl_in[b].gl_Position;"
" vec4 pc = gl_in[c].gl_Position;"
" vec4 px, py;"
" if(ld[a] == 0.0 && ld[b] == 0.0)"
" {"
" px = pa;"
" py = pb;"
" }"
" else if(ld[a] > 0.0 && ld[b] < 0.0)"
" {"
" float x = ld[a]/(ld[a]-ld[b]);"
" float y;"
" px = mix(pa, pb, x);"
" if(ld[c] < 0.0)"
" {"
" y = ld[a]/(ld[a]-ld[c]);"
" py = mix(pa, pc, y);"
" }"
" else"
" {"
" y = ld[c]/(ld[c]-ld[b]);"
" py = mix(pc, pb, y);"
" }"
" }"
" else continue;"
" vec3 vx = px.xyz - LightPos;"
" vec3 vy = py.xyz - LightPos;"
" vec4 sx = vec4(px.xyz + vx*10.0, 1.0);"
" vec4 sy = vec4(py.xyz + vy*10.0, 1.0);"
" vec4 cpx = CameraMatrix * px;"
" vec4 cpy = CameraMatrix * py;"
" vec4 csx = CameraMatrix * sx;"
" vec4 csy = CameraMatrix * sy;"
" gl_Position = ProjectionMatrix * cpy;"
" EmitVertex();"
" gl_Position = ProjectionMatrix * cpx;"
" EmitVertex();"
" gl_Position = ProjectionMatrix * csy;"
" EmitVertex();"
" gl_Position = ProjectionMatrix * csx;"
" EmitVertex();"
" EndPrimitive();"
" break;"
" }"
"}"
);
gs_shadow.Compile();
fs_shadow.Source(
"#version 150\n"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(0.0, 0.0, 0.0, 1.0);"
"}"
);
fs_shadow.Compile();
shadow_prog.AttachShader(vs_shadow);
shadow_prog.AttachShader(gs_shadow);
shadow_prog.AttachShader(fs_shadow);
shadow_prog.Link().Use();
shadow_projection_matrix.BindTo("ProjectionMatrix");
shadow_camera_matrix.BindTo("CameraMatrix");
shadow_model_matrix.BindTo("ModelMatrix");
// bind the VAO for the torus
torus.Bind();
// bind the VBO for the torus vertices
torus_verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(
VertexArrayAttrib::GetCommonLocation(
MakeGroup(object_prog, shadow_prog),
"Position"
)
);
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus normals
torus_normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
object_prog.Use();
VertexArrayAttrib attr(object_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VAO for the plane
plane.Bind();
// bind the VBO for the plane vertices
plane_verts.Bind(Buffer::Target::Array);
{
GLfloat data[4*3] = {
-9.0f, 0.0f, -9.0f,
-9.0f, 0.0f, 9.0f,
9.0f, 0.0f, -9.0f,
9.0f, 0.0f, 9.0f
};
Buffer::Data(Buffer::Target::Array, 4*3, data);
object_prog.Use();
VertexArrayAttrib attr(object_prog, "Position");
attr.Setup<GLfloat>(3);
attr.Enable();
}
// bind the VBO for the torus normals
plane_normals.Bind(Buffer::Target::Array);
{
GLfloat data[4*3] = {
-0.1f, 1.0f, 0.1f,
-0.1f, 1.0f, -0.1f,
0.1f, 1.0f, 0.1f,
0.1f, 1.0f, -0.1f
};
Buffer::Data(Buffer::Target::Array, 4*3, data);
object_prog.Use();
VertexArrayAttrib attr(object_prog, "Normal");
attr.Setup<GLfloat>(3);
attr.Enable();
}
Vec3f lightPos(2.0f, 9.0f, 3.0f);
ProgramUniform<Vec3f>(object_prog, "LightPos").Set(lightPos);
ProgramUniform<Vec3f>(shadow_prog, "LightPos").Set(lightPos);
gl.ClearColor(0.2f, 0.2f, 0.2f, 0.0f);
gl.ClearDepth(1.0f);
gl.ClearStencil(0);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
}
void Reshape(GLuint width, GLuint height)
{
gl.Viewport(width, height);
Mat4f projection = CamMatrixf::PerspectiveX(
Degrees(70),
float(width)/height,
1, 30
);
object_prog.Use();
object_projection_matrix.Set(projection);
shadow_prog.Use();
shadow_projection_matrix.Set(projection);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();
auto camera = CamMatrixf::Orbiting(
Vec3f(),
9.0,
FullCircles(time * 0.1),
Degrees(15 + (-SineWave(0.25+time/12.5)+1.0)* 0.5 * 75)
);
ModelMatrixf identity;
ModelMatrixf model =
ModelMatrixf::Translation(0.0f, 2.5f, 0.0) *
ModelMatrixf::RotationA(
Vec3f(1.0f, 1.0f, 1.0f),
FullCircles(time * 0.2)
);
gl.CullFace(Face::Back);
gl.ColorMask(true, true, true, true);
gl.DepthMask(true);
gl.Disable(Capability::StencilTest);
object_prog.Use();
object_camera_matrix.Set(camera);
object_light_mult.Set(0.2f);
object_model_matrix.Set(identity);
plane.Bind();
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
object_model_matrix.Set(model);
torus.Bind();
torus_instr.Draw(torus_indices);
gl.ColorMask(false, false, false, false);
gl.DepthMask(false);
gl.Enable(Capability::StencilTest);
gl.StencilFunc(CompareFunction::Always, 0);
gl.StencilOpSeparate(
Face::Front,
StencilOp::Keep,
StencilOp::Keep,
StencilOp::Incr
);
gl.StencilOpSeparate(
Face::Back,
StencilOp::Keep,
StencilOp::Keep,
StencilOp::Decr
);
shadow_prog.Use();
shadow_camera_matrix.Set(camera);
shadow_model_matrix.Set(model);
gl.CullFace(Face::Back);
torus_instr.Draw(torus_indices);
gl.CullFace(Face::Front);
torus_instr.Draw(torus_indices);
gl.CullFace(Face::Back);
gl.ColorMask(true, true, true, true);
gl.DepthMask(true);
gl.Clear().DepthBuffer();
gl.StencilFunc(CompareFunction::Equal, 0);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Keep);
object_prog.Use();
object_light_mult.Set(2.5);
object_model_matrix.Set(identity);
object_color.Set(0.8f, 0.7f, 0.4f);
plane.Bind();
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
object_model_matrix.Set(model);
object_color.Set(0.9f, 0.8f, 0.1f);
torus.Bind();
torus_instr.Draw(torus_indices);
}
bool Continue(double time)
{
return time < 60.0;
}
};
void setupExample(ExampleParams& /*params*/){ }
std::unique_ptr<ExampleThread> makeExampleThread(
Example& /*example*/,
unsigned /*thread_id*/,
const ExampleParams& /*params*/
){ return std::unique_ptr<ExampleThread>(); }
std::unique_ptr<Example> makeExample(const ExampleParams& /*params*/)
{
return std::unique_ptr<Example>(new ShadowExample);
}
} // namespace oglplus
| 25.459906 | 87 | 0.663733 | Extrunder |
b4f815035bfbcd3925e92de71c9d44cddd6cd5bf | 18,256 | cpp | C++ | src/chrono_vehicle/tracked_vehicle/ChTrackContactManager.cpp | Ruochun/chrono | 7b0f09242ef540ae56cfc8add3a5dc7985c654d2 | [
"BSD-3-Clause"
] | 1 | 2021-12-09T05:24:42.000Z | 2021-12-09T05:24:42.000Z | src/chrono_vehicle/tracked_vehicle/ChTrackContactManager.cpp | Ruochun/chrono | 7b0f09242ef540ae56cfc8add3a5dc7985c654d2 | [
"BSD-3-Clause"
] | 7 | 2021-10-20T04:43:35.000Z | 2021-12-24T08:44:31.000Z | src/chrono_vehicle/tracked_vehicle/ChTrackContactManager.cpp | Ruochun/chrono | 7b0f09242ef540ae56cfc8add3a5dc7985c654d2 | [
"BSD-3-Clause"
] | 2 | 2021-12-09T05:32:31.000Z | 2021-12-12T17:31:18.000Z | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// Classes for monitoring contacts of tracked vehicle subsystems.
//
// =============================================================================
#include "chrono/physics/ChLoadsBody.h"
#include "chrono_vehicle/tracked_vehicle/ChTrackContactManager.h"
#include "chrono_vehicle/tracked_vehicle/ChTrackedVehicle.h"
namespace chrono {
namespace vehicle {
// -----------------------------------------------------------------------------
ChTrackContactManager::ChTrackContactManager()
: m_initialized(false), m_flags(0), m_collect(false), m_shoe_index_L(0), m_shoe_index_R(0) {
}
void ChTrackContactManager::Process(ChTrackedVehicle* vehicle) {
// Initialize the manager if not already done.
if (!m_initialized) {
m_chassis = vehicle->GetChassis();
m_sprocket_L = vehicle->GetTrackAssembly(LEFT)->GetSprocket();
m_sprocket_R = vehicle->GetTrackAssembly(RIGHT)->GetSprocket();
if (vehicle->GetTrackAssembly(LEFT)->GetNumTrackShoes() > m_shoe_index_L &&
vehicle->GetTrackAssembly(RIGHT)->GetNumTrackShoes() > m_shoe_index_R) {
m_shoe_L = vehicle->GetTrackAssembly(LEFT)->GetTrackShoe(m_shoe_index_L);
m_shoe_R = vehicle->GetTrackAssembly(RIGHT)->GetTrackShoe(m_shoe_index_R);
}
m_idler_L = vehicle->GetTrackAssembly(LEFT)->GetIdler();
m_idler_R = vehicle->GetTrackAssembly(RIGHT)->GetIdler();
m_initialized = true;
}
if (m_flags == 0)
return;
// Clear lists
m_chassis_contacts.clear();
m_sprocket_L_contacts.clear();
m_sprocket_R_contacts.clear();
m_shoe_L_contacts.clear();
m_shoe_R_contacts.clear();
m_idler_L_contacts.clear();
m_idler_R_contacts.clear();
// Traverse all system contacts and extract information.
std::shared_ptr<ChTrackContactManager> shared_this(this, [](ChTrackContactManager*) {});
vehicle->GetSystem()->GetContactContainer()->ReportAllContacts(shared_this);
// Collect contact information data.
// Print current time, and number of contacts involving the chassis, left/right sprockets,
// left/right idlers, left/right track shoes, followed by the location of the contacts, in the
// same order as above, expressed in the local frame of the respective body.
if (m_collect) {
// Get number of contacts in all lists;
size_t n_chassis = m_chassis_contacts.size();
size_t n_sprocket_L = m_sprocket_L_contacts.size();
size_t n_sprocket_R = m_sprocket_R_contacts.size();
size_t n_idler_L = m_idler_L_contacts.size();
size_t n_idler_R = m_idler_R_contacts.size();
size_t n_shoe_L = m_shoe_L_contacts.size();
size_t n_shoe_R = m_shoe_R_contacts.size();
// Only collect data at this time if there is at least one monitored contact
size_t n_contacts = n_chassis + n_sprocket_L + n_sprocket_R + n_idler_L + n_idler_R + n_shoe_L + n_shoe_R;
if (n_contacts != 0) {
// Current simulation time
m_csv << vehicle->GetChTime();
// Number of contacts on vehicle parts
m_csv << m_chassis_contacts.size();
m_csv << m_sprocket_L_contacts.size();
m_csv << m_sprocket_R_contacts.size();
m_csv << m_idler_L_contacts.size();
m_csv << m_idler_R_contacts.size();
m_csv << m_shoe_L_contacts.size();
m_csv << m_shoe_R_contacts.size();
// Chassis contact points
for (const auto& c : m_chassis_contacts) {
m_csv << m_chassis->GetBody()->TransformPointParentToLocal(c.m_point);
}
for (const auto& c : m_sprocket_L_contacts) {
m_csv << m_sprocket_L->GetGearBody()->TransformPointParentToLocal(c.m_point);
}
// Right sprocket contact points
for (const auto& c : m_sprocket_R_contacts) {
m_csv << m_sprocket_R->GetGearBody()->TransformPointParentToLocal(c.m_point);
}
// Left idler contact points
for (const auto& c : m_idler_L_contacts) {
m_csv << m_idler_L->GetWheelBody()->TransformPointParentToLocal(c.m_point);
}
// Right idler contact points
for (const auto& c : m_idler_R_contacts) {
m_csv << m_idler_R->GetWheelBody()->TransformPointParentToLocal(c.m_point);
}
// Left track shoe contact points
if (m_shoe_L) {
for (const auto& c : m_shoe_L_contacts) {
m_csv << m_shoe_L->GetShoeBody()->TransformPointParentToLocal(c.m_point);
}
}
// Right track shoe contact points
if (m_shoe_R) {
for (const auto& c : m_shoe_R_contacts) {
m_csv << m_shoe_R->GetShoeBody()->TransformPointParentToLocal(c.m_point);
}
}
m_csv << std::endl;
}
}
}
// -----------------------------------------------------------------------------
bool ChTrackContactManager::InContact(TrackedCollisionFlag::Enum part) const {
switch (part) {
case TrackedCollisionFlag::CHASSIS:
return m_chassis_contacts.size() != 0;
case TrackedCollisionFlag::SPROCKET_LEFT:
return m_sprocket_L_contacts.size() != 0;
case TrackedCollisionFlag::SPROCKET_RIGHT:
return m_sprocket_R_contacts.size() != 0;
case TrackedCollisionFlag::IDLER_LEFT:
return m_idler_L_contacts.size() != 0;
case TrackedCollisionFlag::IDLER_RIGHT:
return m_idler_R_contacts.size() != 0;
case TrackedCollisionFlag::SHOES_LEFT:
return m_shoe_L_contacts.size() != 0;
case TrackedCollisionFlag::SHOES_RIGHT:
return m_shoe_R_contacts.size() != 0;
default:
return false;
}
}
// -----------------------------------------------------------------------------
ChVector<> ChTrackContactManager::GetSprocketResistiveTorque(VehicleSide side) const {
const auto& contacts = (side == VehicleSide::LEFT) ? m_sprocket_L_contacts : m_sprocket_R_contacts;
const auto& spoint =
(side == VehicleSide::LEFT) ? m_sprocket_L->GetGearBody()->GetPos() : m_sprocket_R->GetGearBody()->GetPos();
ChVector<> torque(0);
for (auto& c : contacts) {
ChVector<> F = c.m_csys * c.m_force;
ChVector<> T = c.m_csys * c.m_torque;
torque += (c.m_point - spoint).Cross(F) + T;
}
return torque;
}
// -----------------------------------------------------------------------------
bool ChTrackContactManager::OnReportContact(const ChVector<>& pA,
const ChVector<>& pB,
const ChMatrix33<>& plane_coord,
const double& distance,
const double& eff_radius,
const ChVector<>& react_forces,
const ChVector<>& react_torques,
ChContactable* modA,
ChContactable* modB) {
ContactInfo info;
// Ignore contacts with zero force or positive separation.
if (distance > 0 || react_forces.IsNull())
return true;
// Extract contacts on chassis.
if (IsFlagSet(TrackedCollisionFlag::CHASSIS)) {
if (modA == m_chassis->GetBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_chassis_contacts.push_back(info);
}
if (modB == m_chassis->GetBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_chassis_contacts.push_back(info);
}
}
// Extract contacts on sprockets.
if (IsFlagSet(TrackedCollisionFlag::SPROCKET_LEFT)) {
if (modA == m_sprocket_L->GetGearBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_sprocket_L_contacts.push_back(info);
}
if (modB == m_sprocket_L->GetGearBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_sprocket_L_contacts.push_back(info);
}
}
if (IsFlagSet(TrackedCollisionFlag::SPROCKET_RIGHT)) {
if (modA == m_sprocket_R->GetGearBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_sprocket_R_contacts.push_back(info);
}
if (modB == m_sprocket_R->GetGearBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_sprocket_R_contacts.push_back(info);
}
}
// Extract contacts on track shoes (discard contacts with sprockets)
if (IsFlagSet(TrackedCollisionFlag::SHOES_LEFT)) {
if (modA == m_shoe_L->GetShoeBody().get() && modB != m_sprocket_L->GetGearBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_shoe_L_contacts.push_back(info);
}
if (modB == m_shoe_L->GetShoeBody().get() && modA != m_sprocket_L->GetGearBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_shoe_L_contacts.push_back(info);
}
}
if (IsFlagSet(TrackedCollisionFlag::SHOES_RIGHT)) {
if (modA == m_shoe_R->GetShoeBody().get() && modB != m_sprocket_R->GetGearBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_shoe_R_contacts.push_back(info);
}
if (modB == m_shoe_R->GetShoeBody().get() && modA != m_sprocket_R->GetGearBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_shoe_R_contacts.push_back(info);
}
}
// Extract contacts on idler wheels.
if (IsFlagSet(TrackedCollisionFlag::IDLER_LEFT)) {
if (modA == m_idler_L->GetWheelBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_idler_L_contacts.push_back(info);
}
if (modB == m_idler_L->GetWheelBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_idler_L_contacts.push_back(info);
}
}
if (IsFlagSet(TrackedCollisionFlag::IDLER_RIGHT)) {
if (modA == m_idler_R->GetWheelBody().get()) {
info.m_point = pA;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_idler_R_contacts.push_back(info);
}
if (modB == m_idler_R->GetWheelBody().get()) {
info.m_point = pB;
info.m_csys = plane_coord;
info.m_force = react_forces;
info.m_torque = react_torques;
m_idler_R_contacts.push_back(info);
}
}
// Continue scanning contacts
return true;
}
void ChTrackContactManager::WriteContacts(const std::string& filename) {
if (m_collect && m_flags != 0)
m_csv.write_to_file(filename);
}
// -----------------------------------------------------------------------------
ChTrackCollisionManager::ChTrackCollisionManager(ChTrackedVehicle* vehicle) : m_idler_shoe(true), m_wheel_shoe(true) {}
void ChTrackCollisionManager::Reset() {
// Empty collision lists
m_collisions_idler.clear();
m_collisions_wheel.clear();
}
static const double nrm_threshold = 0.8;
bool ChTrackCollisionManager::OnNarrowphase(collision::ChCollisionInfo& contactinfo) {
ChBody* bodyA = dynamic_cast<ChBody*>(contactinfo.modelA->GetContactable());
ChBody* bodyB = dynamic_cast<ChBody*>(contactinfo.modelB->GetContactable());
if (!bodyA || !bodyB)
return true;
// Body B is a track shoe body
if (bodyB->GetIdentifier() == BodyID::SHOE_BODY) {
// Express collision normal in body A (wheel) frame
auto nrm = bodyA->TransformDirectionParentToLocal(contactinfo.vN);
// Identify "lateral" contacts (assumed to be with a guiding pin) and let Chrono generate contacts
if (std::abs(nrm.y()) > nrm_threshold) {
return true;
}
// Intercept and cache collisions between wheels and track pad.
// Do not generate Chrono contact for such collisions.
if (m_idler_shoe && bodyA->GetIdentifier() == BodyID::IDLER_BODY) {
m_collisions_idler.push_back(contactinfo);
return false;
}
if (m_wheel_shoe && bodyA->GetIdentifier() == BodyID::WHEEL_BODY) {
m_collisions_wheel.push_back(contactinfo);
return false;
}
}
// Body A is a track shoe body
if (bodyA->GetIdentifier() == BodyID::SHOE_BODY) {
// Express collision normal in body B (wheel) frame
auto nrm = bodyB->TransformDirectionParentToLocal(contactinfo.vN);
// Identify "lateral" contacts (assumed to be with a guiding pin) and let Chrono generate contacts
if (std::abs(nrm.y()) > nrm_threshold) {
return true;
}
// Intercept and cache collisions between wheels and track pad.
// Do not generate Chrono contact for such collisions.
if (m_idler_shoe && bodyB->GetIdentifier() == BodyID::IDLER_BODY) {
auto contactinfoS = contactinfo;
contactinfoS.SwapModels();
m_collisions_idler.push_back(contactinfoS);
return false;
}
if (m_wheel_shoe && bodyB->GetIdentifier() == BodyID::WHEEL_BODY) {
auto contactinfoS = contactinfo;
contactinfoS.SwapModels();
m_collisions_wheel.push_back(contactinfoS);
return false;
}
}
// Let Chrono generate contact for any other collision
return true;
}
// -----------------------------------------------------------------------------
void ChTrackCustomContact::Setup() {
// Calculate contact forces for all current wheel-shoe collisions, calling the user-supplied callback
ApplyForces();
// Perform a full update of the load container
ChLoadContainer::Update(ChTime, false);
}
void ChTrackCustomContact::Update(double mytime, bool update_assets) {
// Note: since Update could be called multiple times per time step, we do not invoke the
// callback function here to calculate custom contact forces (since they are based on collision
// detection information which only occurs once per time step). Instead, we do this in Setup.
// We still override this function to prevent unnecessary calculations in the base class Update.
ChTime = mytime;
}
void ChTrackCustomContact::ApplyForces() {
// Reset the load list for this load container
GetLoadList().clear();
////std::cout << "Idler-shoe collisions: " << m_collision_manager->m_collisions_idler.size() << std::endl;
////std::cout << "Wheel-shoe collisions: " << m_collision_manager->m_collisions_wheel.size() << std::endl;
ChVector<> forceB;
for (auto& cInfo : m_collision_manager->m_collisions_idler) {
std::shared_ptr<ChBody> bodyA(static_cast<ChBody*>(cInfo.modelA->GetContactable()), [](ChBody*) {});
std::shared_ptr<ChBody> bodyB(static_cast<ChBody*>(cInfo.modelB->GetContactable()), [](ChBody*) {});
// Call user-provided force calculation
ComputeForce(cInfo, bodyA, bodyB, true, forceB);
// Apply equal and opposite forces on the two bodies (road wheel and track shoe) in contact
auto loadA = chrono_types::make_shared<ChLoadBodyForce>(bodyA, -forceB, false, cInfo.vpA, false);
auto loadB = chrono_types::make_shared<ChLoadBodyForce>(bodyB, +forceB, false, cInfo.vpB, false);
Add(loadA);
Add(loadB);
}
for (auto& cInfo : m_collision_manager->m_collisions_wheel) {
std::shared_ptr<ChBody> bodyA(static_cast<ChBody*>(cInfo.modelA->GetContactable()), [](ChBody*) {});
std::shared_ptr<ChBody> bodyB(static_cast<ChBody*>(cInfo.modelB->GetContactable()), [](ChBody*) {});
// Call user-provided force calculation
ComputeForce(cInfo, bodyA, bodyB, false, forceB);
// Apply equal and opposite forces on the two bodies (wheel and track shoe) in contact
auto loadA = chrono_types::make_shared<ChLoadBodyForce>(bodyA, -forceB, false, cInfo.vpA, false);
auto loadB = chrono_types::make_shared<ChLoadBodyForce>(bodyB, +forceB, false, cInfo.vpB, false);
Add(loadA);
Add(loadB);
}
}
} // end namespace vehicle
} // end namespace chrono
| 39.686957 | 119 | 0.590436 | Ruochun |
b4f86e0afbd48cc1074fd52fb7cec438690f9009 | 10,381 | cpp | C++ | examples/02Physics/GroundTileMap.cpp | Galhad/firestorm | 3c1584b1e5b95f21d963b9cf226f6ec1a469d7af | [
"MIT"
] | null | null | null | examples/02Physics/GroundTileMap.cpp | Galhad/firestorm | 3c1584b1e5b95f21d963b9cf226f6ec1a469d7af | [
"MIT"
] | null | null | null | examples/02Physics/GroundTileMap.cpp | Galhad/firestorm | 3c1584b1e5b95f21d963b9cf226f6ec1a469d7af | [
"MIT"
] | null | null | null | #include "GroundTileMap.hpp"
#include "Obstacle.hpp"
#include "Collectable.hpp"
namespace fs::scene
{
void GroundTileMap::create(io::InputManager& inputManager, physics::PhysicsManager& physicsManager,
graphics::SpriteSheet& tilesSpriteSheet, graphics::SpriteSheet& itemsSpriteSheet)
{
GroundTileMap::tilesSpriteSheet = &tilesSpriteSheet;
GroundTileMap::itemsSpriteSheet = &itemsSpriteSheet;
createSprites();
core::Vector2i size{40, 20};
core::Vector2f tileSize{grassLeftSprite->getWidthUnits(), grassLeftSprite->getHeightUnits()};
TileMapSceneNode::create(inputManager, size, tileSize);
setTileBuilderCallback([&](core::fs_int32 id) -> SceneNode*
{
const graphics::Sprite* sprite = nullptr;
if (id == leftId)
{
return createGroundBrick(grassLeftSprite, physicsManager);
}
else if (id == midId)
{
return createGroundBrick(grassMidSprite, physicsManager);
}
else if (id == rightId)
{
return createGroundBrick(grassRightSprite, physicsManager);
}
else if (id == plantId)
{
auto* spriteSceneNode = new SpriteSceneNode();
spriteSceneNode->create(inputManager, *plantSprite);
return spriteSceneNode;
}
else if (id == weightId)
{
auto* obstacleSceneNode = new Obstacle();
obstacleSceneNode->create(inputManager, *weightSprite, physicsManager);
return obstacleSceneNode;
}
else if (id == coinId)
{
auto* collectableSceneNode = new Collectable();
collectableSceneNode->create(inputManager, *coinSprite, physicsManager);
return collectableSceneNode;
}
else
{
throw std::runtime_error("Undefined ground brick");
}
});
//@formatter:off
std::vector<std::vector<core::fs_int32>> ids =
{
{-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, -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, -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, -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, -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, -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, -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, -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, -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, -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, -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, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, plantId, -1, coinId, -1, plantId, -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, -1, -1, -1, -1, -1, leftId, midId, midId, midId, midId, midId, rightId, -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, coinId, coinId, coinId, -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, -1, -1, -1, -1, -1, -1, -1, -1, leftId, midId, rightId, -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, -1, -1, -1, coinId, plantId, coinId, -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, -1, -1, -1, -1, -1, -1, -1, -1, leftId, midId, rightId, -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, -1, -1, -1, -1, -1, weightId, -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, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, leftId, midId, rightId, -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},
{-1, -1, -1, -1, -1, plantId, coinId, plantId, -1, -1, -1, -1, -1, -1, -1, -1, -1, coinId, coinId, coinId, coinId, -1, -1, coinId, -1, plantId, -1, coinId, -1, plantId, -1, -1, weightId, coinId, -1, -1, coinId, coinId, coinId, coinId},
{leftId, midId, rightId, -1, leftId, midId, midId, midId, rightId, -1, -1, -1, -1, -1, -1, -1, -1, leftId, midId, midId, rightId, -1, -1, leftId, midId, midId, midId, midId, midId, midId, midId, midId, midId, rightId, -1, -1, leftId, midId, midId, rightId},
{-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, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
};
//@formatter:on
setTilesIds(ids);
}
GroundBrick*
GroundTileMap::createGroundBrick(const graphics::Sprite* sprite, physics::PhysicsManager& physicsManager) const
{
auto* groundBrick = new GroundBrick();
groundBrick->create(*inputManager, *sprite, physicsManager);
return groundBrick;
}
void GroundTileMap::createSprites()
{
grassLeftSprite = tilesSpriteSheet->addSprite({504, 648, 70, 70});
grassMidSprite = tilesSpriteSheet->addSprite({504, 576, 70, 70});
grassRightSprite = tilesSpriteSheet->addSprite({504, 504, 70, 70});
plantSprite = itemsSpriteSheet->addSprite({0, 363, 70, 70});
cactusSprite = itemsSpriteSheet->addSprite({360, 216, 70, 70});
weightSprite = itemsSpriteSheet->addSprite({490, 144, 70, 70});
coinSprite = itemsSpriteSheet->addSprite({288, 360, 70, 70});
}
void GroundTileMap::destroy()
{
TileMapSceneNode::destroy();
}
void GroundTileMap::setTilesIds(const std::vector<std::vector<core::fs_int32>>& vector)
{
for (core::fs_int64 y = 0; y < vector.size(); ++y)
{
for (core::fs_int64 x = 0; x < vector[y].size(); ++x)
{
setTileId(core::Vector2i{x, y}, vector[y][x]);
}
}
}
}
| 84.398374 | 320 | 0.305173 | Galhad |
b4fec66f6482b86d26b9c51e614b5a28808d92c1 | 2,697 | cpp | C++ | src/AcadosSolver.cpp | TorBorve/mpc_local_planner | b237f9df5ff77d4f7282c4df1469ab357e56237e | [
"MIT"
] | 3 | 2021-12-15T06:51:02.000Z | 2021-12-20T11:56:11.000Z | src/AcadosSolver.cpp | TorBorve/mpc-local-planner | b237f9df5ff77d4f7282c4df1469ab357e56237e | [
"MIT"
] | 3 | 2021-12-17T12:22:28.000Z | 2022-02-19T22:18:44.000Z | src/AcadosSolver.cpp | TorBorve/mpc-local-planner | b237f9df5ff77d4f7282c4df1469ab357e56237e | [
"MIT"
] | 4 | 2021-12-15T06:51:15.000Z | 2022-03-05T13:09:51.000Z | #include "mpc_local_planner/AcadosSolver.h"
#include <ros/ros.h>
namespace mpc {
namespace Acados {
void Solver::reInit(const State &state) {
freeAllocated();
init();
setInitGuess(state);
return;
}
void Solver::setInitCondition(const State &state) {
// initial condition
auto x0 = state.toArray();
std::vector<int> idxbx0(x0.size());
// int idxbx0[x0.size()];
for (int i = 0; i < x0.size(); i++) {
idxbx0[i] = i;
}
ocp_nlp_constraints_model_set(config_, dims_, in_, 0, "idxbx", &idxbx0[0]);
ocp_nlp_constraints_model_set(config_, dims_, in_, 0, "lbx", &x0[0]);
ocp_nlp_constraints_model_set(config_, dims_, in_, 0, "ubx", &x0[0]);
}
MPCReturn Solver::solve(const State &state, const Params ¶ms) {
auto start = std::chrono::high_resolution_clock::now();
int N = dims_->N;
setInitCondition(state);
setParams(params);
// prepare evaluation
int NTIMINGS = 1;
std::vector<double> xtraj(nx_ * (N + 1));
std::vector<double> utraj(nx_ * (N));
// solve ocp in loop
int rti_phase = 0;
int status;
for (int ii = 0; ii < NTIMINGS; ii++) {
ocp_nlp_solver_opts_set(config_, opts_, "rti_phase", &rti_phase);
status = acadosSolve();
}
// get the solution
for (int ii = 0; ii <= dims_->N; ii++)
ocp_nlp_out_get(config_, dims_, out_, ii, "x", &xtraj[ii * nx_]);
for (int ii = 0; ii < dims_->N; ii++)
ocp_nlp_out_get(config_, dims_, out_, ii, "u", &utraj[ii * nu_]);
if (status != ACADOS_SUCCESS) {
ROS_ERROR("acados_solve() failed with status %d.\n", status);
reInit(state);
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
MPCReturn ret;
ret.mpcHorizon.resize(N);
for (int i = 0; i < N; i++) {
State state(&xtraj[nx_ * i], nx_);
Input input(&utraj[nu_ * i], nu_);
ret.mpcHorizon.at(i) = OptVariables{state, input};
}
ret.u0 = ret.mpcHorizon.at(0).u;
ret.cost = -1;
ret.success = status == ACADOS_SUCCESS;
ret.computeTime = duration.count();
return ret;
}
void Solver::setInitGuess(const State &state) {
auto x_init = state.toArray();
assert(x_init.size() == nx_);
// initial value for control input
std::vector<double> u0(nu_);
for (int i = 0; i < nu_; i++) {
u0[0] = 0;
}
// initialize solution
for (int i = 0; i <= dims_->N; i++) {
ocp_nlp_out_set(config_, dims_, out_, i, "x", &x_init[0]);
ocp_nlp_out_set(config_, dims_, out_, i, "u", &u0[0]);
}
}
} // namespace Acados
} // namespace mpc | 28.389474 | 87 | 0.597701 | TorBorve |
37003536421cc7186519a875e41bdbe254461a6d | 5,366 | hpp | C++ | src/graphlab/rpc/object_request_issue.hpp | zgdahai/graphlabapi | 7d66bbda82d4d44cded35f9438e1c9359b0ca64e | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2016-11-07T05:47:18.000Z | 2016-11-07T05:47:18.000Z | src/graphlab/rpc/object_request_issue.hpp | keerthanashanmugam/graphlabapi | 7d66bbda82d4d44cded35f9438e1c9359b0ca64e | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | src/graphlab/rpc/object_request_issue.hpp | keerthanashanmugam/graphlabapi | 7d66bbda82d4d44cded35f9438e1c9359b0ca64e | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2009 Carnegie Mellon University.
* 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.
*
* For more about this software visit:
*
* http://www.graphlab.ml.cmu.edu
*
*/
#ifndef OBJECT_REQUEST_ISSUE_HPP
#define OBJECT_REQUEST_ISSUE_HPP
#include <sstream>
#include <iostream>
#include <string>
#include <graphlab/serialization/serialization_includes.hpp>
#include <graphlab/rpc/dc_types.hpp>
#include <graphlab/rpc/dc_internal_types.hpp>
#include <graphlab/rpc/reply_increment_counter.hpp>
#include <graphlab/rpc/object_request_dispatch.hpp>
#include <graphlab/rpc/function_ret_type.hpp>
#include <graphlab/rpc/mem_function_arg_types_def.hpp>
#include <graphlab/rpc/request_future.hpp>
#include <graphlab/rpc/archive_memory_pool.hpp>
#include <graphlab/rpc/dc_compile_parameters.hpp>
#include <boost/preprocessor.hpp>
namespace graphlab {
namespace dc_impl {
#define GENARGS(Z,N,_) BOOST_PP_CAT(const T, N) BOOST_PP_CAT(&i, N)
#define GENT(Z,N,_) BOOST_PP_CAT(T, N)
#define GENARC(Z,N,_) arc << BOOST_PP_CAT(i, N);
/**
\internal
\ingroup rpc
\file object_request_issue.hpp
This is an internal function and should not be used directly
This is the marshall function for the an object member function call.
This is very similar to the standard function request issue in request_issue.hpp
, with the only difference that an object id has to be transmitted
An annoyingly long sequence of type manipulations are needed to identify the return type.
\code
template<typename T,
typename F ,
typename T0> class object_request_issue1
{
public:
static request_future<typename function_ret_type<
typename boost::remove_const<
typename boost::remove_reference<
typename boost::function<
typename boost::remove_member_pointer<F>
::type>::result_type>::type>::type>::type (void)>
exec(dc_send* sender, unsigned char flags, procid_t target,size_t objid, F remote_function , const T0 &i0 )
{
oarchive arc;
arc.advance(sizeof(packet_hdr));
reply_ret_type reply(1);
dispatch_type d = dc_impl::OBJECT_NONINTRUSIVE_REQUESTDISPATCH1<distributed_control,T,F , T0 >;
arc << reinterpret_cast<size_t>(d);
serialize(arc, (char*)(&remote_function), sizeof(remote_function));
arc << objid;
arc << reinterpret_cast<size_t>(reply.reply.get());
arc << i0;
sender->send_data(target, flags, arc.buf, arc.off);
reply.wait();
iarchive iarc(reply.val.c, reply.val.len);
typename function_ret_type<
typename boost::remove_const<
typename boost::remove_reference<
typename boost::function<
typename boost::remove_member_pointer<F>
::type>::result_type>::type>::type>::type result;
iarc >> result;
reply.val.free();
return result;
}
};
\endcode
*/
#define REMOTE_REQUEST_ISSUE_GENERATOR(Z,N,FNAME_AND_CALL) \
template<typename T,typename F BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N, typename T)> \
class BOOST_PP_CAT(FNAME_AND_CALL, N) { \
public: \
static request_future<__GLRPC_FRESULT> exec(dc_dist_object_base* rmi, dc_send* sender, unsigned char flags, procid_t target,size_t objid, F remote_function BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM(N,GENARGS ,_) ) { \
oarchive* ptr = oarchive_from_pool(); \
oarchive& arc = *ptr; \
arc.advance(sizeof(size_t) + sizeof(packet_hdr)); \
request_future<__GLRPC_FRESULT> reply; \
dispatch_type d = BOOST_PP_CAT(dc_impl::OBJECT_NONINTRUSIVE_REQUESTDISPATCH,N)<distributed_control,T,F BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM(N, GENT ,_) >; \
arc << reinterpret_cast<size_t>(d); \
serialize(arc, (char*)(&remote_function), sizeof(remote_function)); \
arc << objid; \
arc << reinterpret_cast<size_t>(reply.reply.get()); \
BOOST_PP_REPEAT(N, GENARC, _) \
if (arc.off >= BUFFER_RELINQUISH_LIMIT) { \
sender->send_data(target,flags , arc.buf, arc.off); \
arc.buf = NULL; arc.len = 0; \
} else { \
char* newbuf = (char*)malloc(arc.off); memcpy(newbuf, arc.buf, arc.off); \
sender->send_data(target,flags , newbuf, arc.off); \
} \
release_oarchive_to_pool(ptr); \
if ((flags & CONTROL_PACKET) == 0) \
rmi->inc_bytes_sent(target, arc.off - sizeof(size_t)); \
return reply; \
}\
};
BOOST_PP_REPEAT(6, REMOTE_REQUEST_ISSUE_GENERATOR, object_request_issue )
#undef GENARC
#undef GENT
#undef GENARGS
#undef REMOTE_REQUEST_ISSUE_GENERATOR
} // namespace dc_impl
} // namespace graphlab
#include <graphlab/rpc/mem_function_arg_types_undef.hpp>
#endif
| 36.013423 | 213 | 0.684122 | zgdahai |
3700ffd26095888ed88e80f7014e9b3c1a5932db | 3,723 | cpp | C++ | YSQFace/src/main/cpp/facedetectcnn-jni.cpp | zhu260824/FaceDetection | 99d5170dbcdac0da6c0c21b717b0ff42214790f0 | [
"Apache-2.0"
] | 2 | 2019-06-22T09:44:19.000Z | 2019-06-27T00:58:12.000Z | YSQFace/src/main/cpp/facedetectcnn-jni.cpp | zhu260824/FaceDetection | 99d5170dbcdac0da6c0c21b717b0ff42214790f0 | [
"Apache-2.0"
] | null | null | null | YSQFace/src/main/cpp/facedetectcnn-jni.cpp | zhu260824/FaceDetection | 99d5170dbcdac0da6c0c21b717b0ff42214790f0 | [
"Apache-2.0"
] | 2 | 2019-06-27T00:58:13.000Z | 2021-01-04T18:11:30.000Z | #include <jni.h>
#include <string>
#include <android/log.h>
#include "facedetectcnn.h"
#include <opencv2/opencv.hpp>
//define the buffer size. Do not change the size!
#define DETECT_BUFFER_SIZE 0x20000
using namespace cv;
extern "C" {
char *JNITag = const_cast<char *>("face-jni");
JNIEXPORT jobjectArray JNICALL
Java_com_zl_face_YSQFaceUtil_detectCNN(JNIEnv *env, jobject /* this */, jlong matAddr) {
jobjectArray faceArgs = nullptr;
Mat &img = *(Mat *) matAddr;
Mat bgr = img.clone();
cvtColor(img, bgr, COLOR_RGBA2BGR);
__android_log_print(ANDROID_LOG_INFO, JNITag, "convert RGBA to RGB");
if (bgr.empty()) {
fprintf(stderr, "Can not convert image");
return faceArgs;
}
int *pResults = NULL;
//pBuffer is used in the detection functions.
//If you call functions in multiple threads, please create one buffer for each thread!
unsigned char *pBuffer = (unsigned char *) malloc(DETECT_BUFFER_SIZE);
if (!pBuffer) {
fprintf(stderr, "Can not alloc buffer.\n");
return faceArgs;
}
///////////////////////////////////////////
// CNN face detection
// Best detection rate
//////////////////////////////////////////
//!!! The input image must be a RGB one (three-channel)
//!!! DO NOT RELEASE pResults !!!
pResults = facedetect_cnn(pBuffer, (unsigned char *) (bgr.ptr(0)), bgr.cols, bgr.rows,(int) bgr.step);
int numOfFaces = pResults ? *pResults : 0;
__android_log_print(ANDROID_LOG_INFO, JNITag, "%d faces detected.\n", numOfFaces);
/**
* 获取Face类以及其对于参数的签名
*/
jclass faceClass = env->FindClass("com/zl/face/YSQFaceInfo");//获取Face类
jmethodID faceClassInitID = (env)->GetMethodID(faceClass, "<init>", "()V");
jfieldID faceConfidence = env->GetFieldID(faceClass, "faceConfidence","I");//获取int类型参数confidence
jfieldID faceAngle = env->GetFieldID(faceClass, "faceAngle", "I");//获取int数组类型参数angle
jfieldID faceRect = env->GetFieldID(faceClass, "faceRect","Landroid/graphics/Rect;");//获取faceRect的签名
/**
* 获取RECT类以及对应参数的签名
*/
jclass rectClass = env->FindClass("android/graphics/Rect");//获取到RECT类
jmethodID rectClassInitID = (env)->GetMethodID(rectClass, "<init>", "()V");
jfieldID rect_left = env->GetFieldID(rectClass, "left", "I");//获取x的签名
jfieldID rect_top = env->GetFieldID(rectClass, "top", "I");//获取y的签名
jfieldID rect_right = env->GetFieldID(rectClass, "right", "I");//获取width的签名
jfieldID rect_bottom = env->GetFieldID(rectClass, "bottom", "I");//获取height的签名
faceArgs = (env)->NewObjectArray(numOfFaces, faceClass, 0);
//print the detection results
for (int i = 0; i < (pResults ? *pResults : 0); i++) {
short *p = ((short *) (pResults + 1)) + 142 * i;
int x = p[0];
int y = p[1];
int w = p[2];
int h = p[3];
int confidence = p[4];
int angle = p[5];
__android_log_print(ANDROID_LOG_INFO, JNITag,"face_rect=[%d, %d, %d, %d], confidence=%d, angle=%d\n", x, y, w, h,confidence, angle);
jobject newFace = (env)->NewObject(faceClass, faceClassInitID);
jobject newRect = (env)->NewObject(rectClass, rectClassInitID);
(env)->SetIntField(newRect, rect_left, x);
(env)->SetIntField(newRect, rect_top, y);
(env)->SetIntField(newRect, rect_right, x + w);
(env)->SetIntField(newRect, rect_bottom, y + h);
(env)->SetObjectField(newFace, faceRect, newRect);
(env)->SetIntField(newFace, faceConfidence, confidence);
(env)->SetIntField(newFace, faceAngle, angle);
(env)->SetObjectArrayElement(faceArgs, i, newFace);
}
//release the buffer
free(pBuffer);
return faceArgs;
}
}; | 43.290698 | 140 | 0.633629 | zhu260824 |
37044b7c153036b9e11efa48a25888f5832b52fe | 27,213 | cpp | C++ | extras/Projucer/Source/Project/jucer_Module.cpp | Hanley1/JUCE | e583f7b9927cd5b47cf151b9f7210a727b68b572 | [
"ISC"
] | null | null | null | extras/Projucer/Source/Project/jucer_Module.cpp | Hanley1/JUCE | e583f7b9927cd5b47cf151b9f7210a727b68b572 | [
"ISC"
] | null | null | null | extras/Projucer/Source/Project/jucer_Module.cpp | Hanley1/JUCE | e583f7b9927cd5b47cf151b9f7210a727b68b572 | [
"ISC"
] | null | null | null | /*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2017 - ROLI Ltd.
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 5 End-User License
Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
27th April 2017).
End User License Agreement: www.juce.com/juce-5-licence
Privacy Policy: www.juce.com/juce-5-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
#include "../Application/jucer_Headers.h"
#include "../ProjectSaving/jucer_ProjectSaver.h"
#include "../ProjectSaving/jucer_ProjectExport_Xcode.h"
#include "../Application/jucer_Application.h"
//==============================================================================
ModuleDescription::ModuleDescription (const File& folder)
: moduleFolder (folder),
moduleInfo (parseJUCEHeaderMetadata (getHeader()))
{
}
File ModuleDescription::getHeader() const
{
if (moduleFolder != File())
{
const char* extensions[] = { ".h", ".hpp", ".hxx" };
for (auto e : extensions)
{
auto header = moduleFolder.getChildFile (moduleFolder.getFileName() + e);
if (header.existsAsFile())
return header;
}
}
return {};
}
StringArray ModuleDescription::getDependencies() const
{
auto deps = StringArray::fromTokens (moduleInfo ["dependencies"].toString(), " \t;,", "\"'");
deps.trim();
deps.removeEmptyStrings();
return deps;
}
//==============================================================================
static bool tryToAddModuleFromFolder (const File& path, ModuleIDAndFolderList& list)
{
ModuleDescription m (path);
if (m.isValid())
{
list.push_back ({ m.getID(), path });
return true;
}
return false;
}
static void addAllModulesInSubfoldersRecursively (const File& path, int depth, ModuleIDAndFolderList& list)
{
if (depth > 0)
{
for (DirectoryIterator iter (path, false, "*", File::findDirectories); iter.next();)
{
if (auto* job = ThreadPoolJob::getCurrentThreadPoolJob())
if (job->shouldExit())
return;
auto childPath = iter.getFile();
if (! tryToAddModuleFromFolder (childPath, list))
addAllModulesInSubfoldersRecursively (childPath, depth - 1, list);
}
}
}
static void addAllModulesInFolder (const File& path, ModuleIDAndFolderList& list)
{
if (! tryToAddModuleFromFolder (path, list))
{
int subfolders = 3;
addAllModulesInSubfoldersRecursively (path, subfolders, list);
}
}
static void sort (ModuleIDAndFolderList& listToSort)
{
std::sort (listToSort.begin(), listToSort.end(), [] (const ModuleIDAndFolder& m1, const ModuleIDAndFolder& m2)
{
return m1.first.compareIgnoreCase (m2.first) < 0;
});
}
//==============================================================================
struct ModuleScannerJob : public ThreadPoolJob
{
ModuleScannerJob (const Array<File>& paths, std::function<void (const ModuleIDAndFolderList&)>&& callback)
: ThreadPoolJob ("ModuleScannerJob"),
pathsToScan (paths),
completionCallback (std::move (callback))
{
}
JobStatus runJob() override
{
ModuleIDAndFolderList list;
for (auto& p : pathsToScan)
addAllModulesInFolder (p, list);
if (! shouldExit())
{
sort (list);
completionCallback (list);
}
return jobHasFinished;
}
Array<File> pathsToScan;
std::function<void (const ModuleIDAndFolderList&)> completionCallback;
};
AvailableModuleList::AvailableModuleList()
{
}
ThreadPoolJob* AvailableModuleList::createScannerJob (const Array<File>& paths)
{
return new ModuleScannerJob (paths, [this] (ModuleIDAndFolderList scannedModuleList)
{
{
const ScopedLock swapLock (lock);
moduleList.swap (scannedModuleList);
}
listeners.call ([] (Listener& l) { MessageManager::callAsync ([&] { l.availableModulesChanged(); }); });
});
}
void AvailableModuleList::removePendingAndAddJob (ThreadPoolJob* jobToAdd)
{
scanPool.removeAllJobs (false, 100);
scanPool.addJob (jobToAdd, true);
}
void AvailableModuleList::scanPaths (const Array<File>& paths)
{
auto* job = createScannerJob (paths);
removePendingAndAddJob (job);
scanPool.waitForJobToFinish (job, -1);
}
void AvailableModuleList::scanPathsAsync (const Array<File>& paths)
{
removePendingAndAddJob (createScannerJob (paths));
}
ModuleIDAndFolderList AvailableModuleList::getAllModules() const
{
const ScopedLock readLock (lock);
return moduleList;
}
ModuleIDAndFolder AvailableModuleList::getModuleWithID (const String& id) const
{
const ScopedLock readLock (lock);
for (auto& mod : moduleList)
if (mod.first == id)
return mod;
return {};
}
void AvailableModuleList::removeDuplicates (const ModuleIDAndFolderList& other)
{
const ScopedLock readLock (lock);
for (auto& m : other)
{
auto pos = std::find (moduleList.begin(), moduleList.end(), m);
if (pos != moduleList.end())
moduleList.erase (pos);
}
}
//==============================================================================
LibraryModule::LibraryModule (const ModuleDescription& d)
: moduleInfo (d)
{
}
//==============================================================================
void LibraryModule::writeIncludes (ProjectSaver& projectSaver, OutputStream& out)
{
auto& project = projectSaver.project;
auto& modules = project.getEnabledModules();
auto id = getID();
if (modules.shouldCopyModuleFilesLocally (id).getValue())
{
auto juceModuleFolder = moduleInfo.getFolder();
auto localModuleFolder = project.getLocalModuleFolder (id);
localModuleFolder.createDirectory();
projectSaver.copyFolder (juceModuleFolder, localModuleFolder);
}
out << "#include <" << moduleInfo.moduleFolder.getFileName() << "/"
<< moduleInfo.getHeader().getFileName()
<< ">" << newLine;
}
//==============================================================================
static void parseAndAddLibs (StringArray& libList, const String& libs)
{
libList.addTokens (libs, ", ", {});
libList.trim();
libList.removeDuplicates (false);
}
void LibraryModule::addSettingsForModuleToExporter (ProjectExporter& exporter, ProjectSaver& projectSaver) const
{
auto& project = exporter.getProject();
auto moduleRelativePath = exporter.getModuleFolderRelativeToProject (getID());
exporter.addToExtraSearchPaths (moduleRelativePath.getParentDirectory());
String libDirPlatform;
if (exporter.isLinux())
libDirPlatform = "Linux";
else if (exporter.isCodeBlocks() && exporter.isWindows())
libDirPlatform = "MinGW";
else
libDirPlatform = exporter.getTargetFolder().getFileName();
auto libSubdirPath = moduleRelativePath.toUnixStyle() + "/libs/" + libDirPlatform;
auto moduleLibDir = File (project.getProjectFolder().getFullPathName() + "/" + libSubdirPath);
if (moduleLibDir.exists())
exporter.addToModuleLibPaths ({ libSubdirPath, moduleRelativePath.getRoot() });
auto extraInternalSearchPaths = moduleInfo.getExtraSearchPaths().trim();
if (extraInternalSearchPaths.isNotEmpty())
{
auto paths = StringArray::fromTokens (extraInternalSearchPaths, true);
for (auto& path : paths)
exporter.addToExtraSearchPaths (moduleRelativePath.getChildFile (path.unquoted()));
}
{
auto extraDefs = moduleInfo.getPreprocessorDefs().trim();
if (extraDefs.isNotEmpty())
exporter.getExporterPreprocessorDefsValue() = exporter.getExporterPreprocessorDefsString() + "\n" + extraDefs;
}
{
Array<File> compiled;
auto& modules = project.getEnabledModules();
auto id = getID();
auto localModuleFolder = modules.shouldCopyModuleFilesLocally (id).getValue() ? project.getLocalModuleFolder (id)
: moduleInfo.getFolder();
findAndAddCompiledUnits (exporter, &projectSaver, compiled);
if (modules.shouldShowAllModuleFilesInProject (id).getValue())
addBrowseableCode (exporter, compiled, localModuleFolder);
}
if (exporter.isXcode())
{
auto& xcodeExporter = dynamic_cast<XcodeProjectExporter&> (exporter);
if (project.isAUPluginHost())
xcodeExporter.xcodeFrameworks.addTokens (xcodeExporter.isOSX() ? "AudioUnit CoreAudioKit" : "CoreAudioKit", false);
auto frameworks = moduleInfo.moduleInfo [xcodeExporter.isOSX() ? "OSXFrameworks" : "iOSFrameworks"].toString();
xcodeExporter.xcodeFrameworks.addTokens (frameworks, ", ", {});
parseAndAddLibs (xcodeExporter.xcodeLibs, moduleInfo.moduleInfo [exporter.isOSX() ? "OSXLibs" : "iOSLibs"].toString());
}
else if (exporter.isLinux())
{
parseAndAddLibs (exporter.linuxLibs, moduleInfo.moduleInfo ["linuxLibs"].toString());
parseAndAddLibs (exporter.linuxPackages, moduleInfo.moduleInfo ["linuxPackages"].toString());
}
else if (exporter.isWindows())
{
if (exporter.isCodeBlocks())
parseAndAddLibs (exporter.mingwLibs, moduleInfo.moduleInfo ["mingwLibs"].toString());
else
parseAndAddLibs (exporter.windowsLibs, moduleInfo.moduleInfo ["windowsLibs"].toString());
}
else if (exporter.isAndroid())
{
parseAndAddLibs (exporter.androidLibs, moduleInfo.moduleInfo ["androidLibs"].toString());
}
}
void LibraryModule::getConfigFlags (Project& project, OwnedArray<Project::ConfigFlag>& flags) const
{
auto header = moduleInfo.getHeader();
jassert (header.exists());
StringArray lines;
header.readLines (lines);
for (int i = 0; i < lines.size(); ++i)
{
auto line = lines[i].trim();
if (line.startsWith ("/**") && line.containsIgnoreCase ("Config:"))
{
std::unique_ptr<Project::ConfigFlag> config (new Project::ConfigFlag());
config->sourceModuleID = getID();
config->symbol = line.fromFirstOccurrenceOf (":", false, false).trim();
if (config->symbol.length() > 2)
{
++i;
while (! (lines[i].contains ("*/") || lines[i].contains ("@see")))
{
if (lines[i].trim().isNotEmpty())
config->description = config->description.trim() + " " + lines[i].trim();
++i;
}
config->description = config->description.upToFirstOccurrenceOf ("*/", false, false);
config->value = project.getConfigFlag (config->symbol);
i += 2;
if (lines[i].contains ("#define " + config->symbol))
{
auto value = lines[i].fromFirstOccurrenceOf ("#define " + config->symbol, false, true).trim();
config->value.setDefault (value == "0" ? false : true);
}
auto currentValue = config->value.get().toString();
if (currentValue == "enabled") config->value = true;
else if (currentValue == "disabled") config->value = false;
flags.add (config.release());
}
}
}
}
//==============================================================================
struct FileSorter
{
static int compareElements (const File& f1, const File& f2)
{
return f1.getFileName().compareNatural (f2.getFileName());
}
};
bool LibraryModule::CompileUnit::hasSuffix (const File& f, const char* suffix)
{
auto fileWithoutSuffix = f.getFileNameWithoutExtension() + ".";
return fileWithoutSuffix.containsIgnoreCase (suffix + String ("."))
|| fileWithoutSuffix.containsIgnoreCase (suffix + String ("_"));
}
void LibraryModule::CompileUnit::writeInclude (MemoryOutputStream&) const
{
}
bool LibraryModule::CompileUnit::isNeededForExporter (ProjectExporter& exporter) const
{
if ((hasSuffix (file, "_OSX") && ! exporter.isOSX())
|| (hasSuffix (file, "_iOS") && ! exporter.isiOS())
|| (hasSuffix (file, "_Windows") && ! exporter.isWindows())
|| (hasSuffix (file, "_Linux") && ! exporter.isLinux())
|| (hasSuffix (file, "_Android") && ! exporter.isAndroid()))
return false;
auto targetType = Project::getTargetTypeFromFilePath (file, false);
if (targetType != ProjectType::Target::unspecified && ! exporter.shouldBuildTargetType (targetType))
return false;
return exporter.usesMMFiles() ? isCompiledForObjC
: isCompiledForNonObjC;
}
String LibraryModule::CompileUnit::getFilenameForProxyFile() const
{
return "include_" + file.getFileName();
}
Array<LibraryModule::CompileUnit> LibraryModule::getAllCompileUnits (ProjectType::Target::Type forTarget) const
{
auto files = getFolder().findChildFiles (File::findFiles, false);
FileSorter sorter;
files.sort (sorter);
Array<LibraryModule::CompileUnit> units;
for (auto& file : files)
{
if (file.getFileName().startsWithIgnoreCase (getID())
&& file.hasFileExtension (sourceFileExtensions))
{
if (forTarget == ProjectType::Target::unspecified
|| forTarget == Project::getTargetTypeFromFilePath (file, true))
{
CompileUnit cu;
cu.file = file;
units.add (cu);
}
}
}
for (auto& cu : units)
{
cu.isCompiledForObjC = true;
cu.isCompiledForNonObjC = ! cu.file.hasFileExtension ("mm;m");
if (cu.isCompiledForNonObjC)
if (files.contains (cu.file.withFileExtension ("mm")))
cu.isCompiledForObjC = false;
jassert (cu.isCompiledForObjC || cu.isCompiledForNonObjC);
}
return units;
}
void LibraryModule::findAndAddCompiledUnits (ProjectExporter& exporter,
ProjectSaver* projectSaver,
Array<File>& result,
ProjectType::Target::Type forTarget) const
{
for (auto& cu : getAllCompileUnits (forTarget))
{
if (cu.isNeededForExporter (exporter))
{
auto localFile = exporter.getProject().getGeneratedCodeFolder()
.getChildFile (cu.getFilenameForProxyFile());
result.add (localFile);
if (projectSaver != nullptr)
projectSaver->addFileToGeneratedGroup (localFile);
}
}
}
static void addFileWithGroups (Project::Item& group, const RelativePath& file, const String& path)
{
auto slash = path.indexOfChar (File::getSeparatorChar());
if (slash >= 0)
{
auto topLevelGroup = path.substring (0, slash);
auto remainingPath = path.substring (slash + 1);
auto newGroup = group.getOrCreateSubGroup (topLevelGroup);
addFileWithGroups (newGroup, file, remainingPath);
}
else
{
if (! group.containsChildForFile (file))
group.addRelativeFile (file, -1, false);
}
}
void LibraryModule::findBrowseableFiles (const File& folder, Array<File>& filesFound) const
{
Array<File> tempList;
FileSorter sorter;
DirectoryIterator iter (folder, true, "*", File::findFiles);
bool isHiddenFile;
while (iter.next (nullptr, &isHiddenFile, nullptr, nullptr, nullptr, nullptr))
if (! isHiddenFile && iter.getFile().hasFileExtension (browseableFileExtensions))
tempList.addSorted (sorter, iter.getFile());
filesFound.addArray (tempList);
}
void LibraryModule::addBrowseableCode (ProjectExporter& exporter, const Array<File>& compiled, const File& localModuleFolder) const
{
if (sourceFiles.isEmpty())
findBrowseableFiles (localModuleFolder, sourceFiles);
auto sourceGroup = Project::Item::createGroup (exporter.getProject(), getID(), "__mainsourcegroup" + getID(), false);
auto moduleFromProject = exporter.getModuleFolderRelativeToProject (getID());
auto moduleHeader = moduleInfo.getHeader();
for (auto& sourceFile : sourceFiles)
{
auto pathWithinModule = FileHelpers::getRelativePathFrom (sourceFile, localModuleFolder);
// (Note: in exporters like MSVC we have to avoid adding the same file twice, even if one of those instances
// is flagged as being excluded from the build, because this overrides the other and it fails to compile)
if ((exporter.canCopeWithDuplicateFiles() || ! compiled.contains (sourceFile)) && sourceFile != moduleHeader)
addFileWithGroups (sourceGroup,
moduleFromProject.getChildFile (pathWithinModule),
pathWithinModule);
}
sourceGroup.sortAlphabetically (true, true);
sourceGroup.addFileAtIndex (moduleHeader, -1, false);
exporter.getModulesGroup().state.appendChild (sourceGroup.state.createCopy(), nullptr);
}
//==============================================================================
EnabledModuleList::EnabledModuleList (Project& p, const ValueTree& s)
: project (p), state (s)
{
}
ModuleDescription EnabledModuleList::getModuleInfo (const String& moduleID)
{
return ModuleDescription (project.getModuleWithID (moduleID).second);
}
bool EnabledModuleList::isModuleEnabled (const String& moduleID) const
{
return state.getChildWithProperty (Ids::ID, moduleID).isValid();
}
bool EnabledModuleList::isAudioPluginModuleMissing() const
{
return project.getProjectType().isAudioPlugin()
&& ! isModuleEnabled ("juce_audio_plugin_client");
}
bool EnabledModuleList::shouldUseGlobalPath (const String& moduleID) const
{
return static_cast<bool> (state.getChildWithProperty (Ids::ID, moduleID)
.getProperty (Ids::useGlobalPath));
}
Value EnabledModuleList::getShouldUseGlobalPathValue (const String& moduleID) const
{
return state.getChildWithProperty (Ids::ID, moduleID)
.getPropertyAsValue (Ids::useGlobalPath, getUndoManager());
}
Value EnabledModuleList::shouldShowAllModuleFilesInProject (const String& moduleID)
{
return state.getChildWithProperty (Ids::ID, moduleID)
.getPropertyAsValue (Ids::showAllCode, getUndoManager());
}
struct ModuleTreeSorter
{
static int compareElements (const ValueTree& m1, const ValueTree& m2)
{
return m1[Ids::ID].toString().compareIgnoreCase (m2[Ids::ID]);
}
};
void EnabledModuleList::sortAlphabetically()
{
ModuleTreeSorter sorter;
state.sort (sorter, getUndoManager(), false);
}
Value EnabledModuleList::shouldCopyModuleFilesLocally (const String& moduleID) const
{
return state.getChildWithProperty (Ids::ID, moduleID)
.getPropertyAsValue (Ids::useLocalCopy, getUndoManager());
}
void EnabledModuleList::addModule (const File& moduleFolder, bool copyLocally, bool useGlobalPath, bool sendAnalyticsEvent)
{
ModuleDescription info (moduleFolder);
if (info.isValid())
{
auto moduleID = info.getID();
if (! isModuleEnabled (moduleID))
{
ValueTree module (Ids::MODULE);
module.setProperty (Ids::ID, moduleID, getUndoManager());
state.appendChild (module, getUndoManager());
sortAlphabetically();
shouldShowAllModuleFilesInProject (moduleID) = true;
shouldCopyModuleFilesLocally (moduleID) = copyLocally;
getShouldUseGlobalPathValue (moduleID) = useGlobalPath;
RelativePath path (moduleFolder.getParentDirectory(),
project.getProjectFolder(), RelativePath::projectFolder);
for (Project::ExporterIterator exporter (project); exporter.next();)
exporter->getPathForModuleValue (moduleID) = path.toUnixStyle();
if (! useGlobalPath)
project.rescanExporterPathModules (false);
if (sendAnalyticsEvent)
{
StringPairArray data;
data.set ("label", moduleID);
Analytics::getInstance()->logEvent ("Module Added", data, ProjucerAnalyticsEvent::projectEvent);
}
}
}
}
void EnabledModuleList::removeModule (String moduleID) // must be pass-by-value, and not a const ref!
{
for (auto i = state.getNumChildren(); --i >= 0;)
if (state.getChild(i) [Ids::ID] == moduleID)
state.removeChild (i, getUndoManager());
for (Project::ExporterIterator exporter (project); exporter.next();)
exporter->removePathForModule (moduleID);
}
void EnabledModuleList::createRequiredModules (OwnedArray<LibraryModule>& modules)
{
for (int i = 0; i < getNumModules(); ++i)
modules.add (new LibraryModule (getModuleInfo (getModuleID (i))));
}
StringArray EnabledModuleList::getAllModules() const
{
StringArray moduleIDs;
for (int i = 0; i < getNumModules(); ++i)
moduleIDs.add (getModuleID (i));
return moduleIDs;
}
static void getDependencies (Project& project, const String& moduleID, StringArray& dependencies)
{
auto info = project.getEnabledModules().getModuleInfo (moduleID);
for (auto uid : info.getDependencies())
{
if (! dependencies.contains (uid, true))
{
dependencies.add (uid);
getDependencies (project, uid, dependencies);
}
}
}
StringArray EnabledModuleList::getExtraDependenciesNeeded (const String& moduleID) const
{
StringArray dependencies, extraDepsNeeded;
getDependencies (project, moduleID, dependencies);
for (auto dep : dependencies)
if (dep != moduleID && ! isModuleEnabled (dep))
extraDepsNeeded.add (dep);
return extraDepsNeeded;
}
bool EnabledModuleList::doesModuleHaveHigherCppStandardThanProject (const String& moduleID)
{
auto projectCppStandard = project.getCppStandardString();
if (projectCppStandard == "latest")
return false;
auto moduleCppStandard = getModuleInfo (moduleID).getMinimumCppStandard();
return (moduleCppStandard.getIntValue() > projectCppStandard.getIntValue());
}
bool EnabledModuleList::areMostModulesUsingGlobalPath() const
{
int numYes = 0, numNo = 0;
for (auto i = getNumModules(); --i >= 0;)
{
if (shouldUseGlobalPath (getModuleID (i)))
++numYes;
else
++numNo;
}
return numYes > numNo;
}
bool EnabledModuleList::areMostModulesCopiedLocally() const
{
int numYes = 0, numNo = 0;
for (auto i = getNumModules(); --i >= 0;)
{
if (shouldCopyModuleFilesLocally (getModuleID (i)).getValue())
++numYes;
else
++numNo;
}
return numYes > numNo;
}
void EnabledModuleList::setLocalCopyModeForAllModules (bool copyLocally)
{
for (auto i = getNumModules(); --i >= 0;)
shouldCopyModuleFilesLocally (project.getEnabledModules().getModuleID (i)) = copyLocally;
}
File EnabledModuleList::findDefaultModulesFolder (Project& project)
{
File globalPath (getAppSettings().getStoredPath (Ids::defaultJuceModulePath, TargetOS::getThisOS()).get().toString());
if (globalPath.exists())
return globalPath;
for (auto& exporterPathModule : project.getExporterPathsModuleList().getAllModules())
{
auto f = exporterPathModule.second;
if (f.isDirectory())
return f.getParentDirectory();
}
return File::getCurrentWorkingDirectory();
}
void EnabledModuleList::addModuleFromUserSelectedFile()
{
static auto lastLocation = findDefaultModulesFolder (project);
FileChooser fc ("Select a module to add...", lastLocation, {});
if (fc.browseForDirectory())
{
lastLocation = fc.getResult();
addModuleOfferingToCopy (lastLocation, true);
}
}
void EnabledModuleList::addModuleInteractive (const String& moduleID)
{
auto f = project.getModuleWithID (moduleID).second;
if (f != File())
{
addModule (f, areMostModulesCopiedLocally(), areMostModulesUsingGlobalPath(), true);
return;
}
addModuleFromUserSelectedFile();
}
void EnabledModuleList::addModuleOfferingToCopy (const File& f, bool isFromUserSpecifiedFolder)
{
ModuleDescription m (f);
if (! m.isValid())
{
AlertWindow::showMessageBoxAsync (AlertWindow::InfoIcon,
"Add Module", "This wasn't a valid module folder!");
return;
}
if (isModuleEnabled (m.getID()))
{
AlertWindow::showMessageBoxAsync (AlertWindow::InfoIcon,
"Add Module", "The project already contains this module!");
return;
}
addModule (m.moduleFolder, areMostModulesCopiedLocally(),
isFromUserSpecifiedFolder ? false : areMostModulesUsingGlobalPath(),
true);
}
bool isJUCEFolder (const File& f)
{
return isJUCEModulesFolder (f.getChildFile ("modules"));
}
bool isJUCEModulesFolder (const File& f)
{
return f.isDirectory() && f.getChildFile ("juce_core").isDirectory();
}
| 33.065614 | 149 | 0.597656 | Hanley1 |
3705f4b9f010683aaf4e480e36899e6f259b758f | 487 | hpp | C++ | lib/ldcp_sdk/third_party/Asio/asio-1.12.1/include/asio/yield.hpp | MoveXBot/ltme_node | 988f5c8a7ccc3f962e1c46ea61d7805f7d30bfe5 | [
"Apache-2.0"
] | 27 | 2019-10-24T11:09:06.000Z | 2022-03-22T10:00:51.000Z | lib/ldcp_sdk/third_party/Asio/asio-1.12.1/include/asio/yield.hpp | MoveXBot/ltme_node | 988f5c8a7ccc3f962e1c46ea61d7805f7d30bfe5 | [
"Apache-2.0"
] | 1 | 2019-12-09T06:15:01.000Z | 2019-12-09T06:15:01.000Z | lib/ldcp_sdk/third_party/Asio/asio-1.12.1/include/asio/yield.hpp | MoveXBot/ltme_node | 988f5c8a7ccc3f962e1c46ea61d7805f7d30bfe5 | [
"Apache-2.0"
] | 10 | 2020-01-10T09:10:57.000Z | 2020-06-26T11:03:11.000Z | //
// yield.hpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "coroutine.hpp"
#ifndef reenter
# define reenter(c) ASIO_CORO_REENTER(c)
#endif
#ifndef yield
# define yield ASIO_CORO_YIELD
#endif
#ifndef fork
# define fork ASIO_CORO_FORK
#endif
| 20.291667 | 80 | 0.687885 | MoveXBot |
370845949294c2a5a41ce9bdf6dc86ad624575f2 | 24,507 | cpp | C++ | modules/videostab/samples/videostab.cpp | Kriston-SCT/opencv_contrib | 65abc7090dedc84bbedec4dfd143f0340e52114f | [
"BSD-3-Clause"
] | 3 | 2020-01-02T11:53:17.000Z | 2021-04-10T14:02:20.000Z | modules/videostab/samples/videostab.cpp | Kriston-SCT/opencv_contrib | 65abc7090dedc84bbedec4dfd143f0340e52114f | [
"BSD-3-Clause"
] | 1 | 2020-12-08T15:15:26.000Z | 2020-12-08T15:15:26.000Z | modules/videostab/samples/videostab.cpp | Kriston-SCT/opencv_contrib | 65abc7090dedc84bbedec4dfd143f0340e52114f | [
"BSD-3-Clause"
] | 3 | 2019-09-04T02:01:31.000Z | 2020-01-02T11:53:23.000Z | #include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include "opencv2/core.hpp"
#include <opencv2/core/utility.hpp>
#include "opencv2/video.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/videoio.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/videostab.hpp"
#include "opencv2/opencv_modules.hpp"
#define arg(name) cmd.get<string>(name)
#define argb(name) cmd.get<bool>(name)
#define argi(name) cmd.get<int>(name)
#define argf(name) cmd.get<float>(name)
#define argd(name) cmd.get<double>(name)
using namespace std;
using namespace cv;
using namespace cv::videostab;
Ptr<IFrameSource> stabilizedFrames;
string saveMotionsPath;
double outputFps;
string outputPath;
bool quietMode;
void run();
void saveMotionsIfNecessary();
void printHelp();
MotionModel motionModel(const string &str);
void run()
{
VideoWriter writer;
Mat stabilizedFrame;
int nframes = 0;
// for each stabilized frame
while (!(stabilizedFrame = stabilizedFrames->nextFrame()).empty())
{
nframes++;
// init writer (once) and save stabilized frame
if (!outputPath.empty())
{
if (!writer.isOpened())
writer.open(outputPath, VideoWriter::fourcc('X','V','I','D'),
outputFps, stabilizedFrame.size());
writer << stabilizedFrame;
}
// show stabilized frame
if (!quietMode)
{
imshow("stabilizedFrame", stabilizedFrame);
char key = static_cast<char>(waitKey(3));
if (key == 27) { cout << endl; break; }
}
}
cout << "processed frames: " << nframes << endl
<< "finished\n";
}
void printHelp()
{
cout << "OpenCV video stabilizer.\n"
"Usage: videostab <file_path> [arguments]\n\n"
"Arguments:\n"
" -m=, --model=(transl|transl_and_scale|rigid|similarity|affine|homography)\n"
" Set motion model. The default is affine.\n"
" -lp=, --lin-prog-motion-est=(yes|no)\n"
" Turn on/off LP based motion estimation. The default is no.\n"
" --subset=(<int_number>|auto)\n"
" Number of random samples per one motion hypothesis. The default is auto.\n"
" --thresh=(<float_number>|auto)\n"
" Maximum error to classify match as inlier. The default is auto.\n"
" --outlier-ratio=<float_number>\n"
" Motion estimation outlier ratio hypothesis. The default is 0.5.\n"
" --min-inlier-ratio=<float_number>\n"
" Minimum inlier ratio to decide if estimated motion is OK. The default is 0.1.\n"
" --nkps=<int_number>\n"
" Number of keypoints to find in each frame. The default is 1000.\n"
" --local-outlier-rejection=(yes|no)\n"
" Perform local outlier rejection. The default is no.\n\n"
" --feature-masks=(file_path|no)\n"
" Load masks from file. The default is no.\n\n"
" -sm=, --save-motions=(<file_path>|no)\n"
" Save estimated motions into file. The default is no.\n"
" -lm=, --load-motions=(<file_path>|no)\n"
" Load motions from file. The default is no.\n\n"
" -r=, --radius=<int_number>\n"
" Set sliding window radius. The default is 15.\n"
" --stdev=(<float_number>|auto)\n"
" Set smoothing weights standard deviation. The default is auto\n"
" (i.e. sqrt(radius)).\n"
" -lps=, --lin-prog-stab=(yes|no)\n"
" Turn on/off linear programming based stabilization method.\n"
" --lps-trim-ratio=(<float_number>|auto)\n"
" Trimming ratio used in linear programming based method.\n"
" --lps-w1=(<float_number>|1)\n"
" 1st derivative weight. The default is 1.\n"
" --lps-w2=(<float_number>|10)\n"
" 2nd derivative weight. The default is 10.\n"
" --lps-w3=(<float_number>|100)\n"
" 3rd derivative weight. The default is 100.\n"
" --lps-w4=(<float_number>|100)\n"
" Non-translation motion components weight. The default is 100.\n\n"
" --deblur=(yes|no)\n"
" Do deblurring.\n"
" --deblur-sens=<float_number>\n"
" Set deblurring sensitivity (from 0 to +inf). The default is 0.1.\n\n"
" -t=, --trim-ratio=<float_number>\n"
" Set trimming ratio (from 0 to 0.5). The default is 0.1.\n"
" -et=, --est-trim=(yes|no)\n"
" Estimate trim ratio automatically. The default is yes.\n"
" -ic=, --incl-constr=(yes|no)\n"
" Ensure the inclusion constraint is always satisfied. The default is no.\n\n"
" -bm=, --border-mode=(replicate|reflect|const)\n"
" Set border extrapolation mode. The default is replicate.\n\n"
" --mosaic=(yes|no)\n"
" Do consistent mosaicing. The default is no.\n"
" --mosaic-stdev=<float_number>\n"
" Consistent mosaicing stdev threshold. The default is 10.0.\n\n"
" -mi=, --motion-inpaint=(yes|no)\n"
" Do motion inpainting (requires CUDA support). The default is no.\n"
" --mi-dist-thresh=<float_number>\n"
" Estimated flow distance threshold for motion inpainting. The default is 5.0.\n\n"
" -ci=, --color-inpaint=(no|average|ns|telea)\n"
" Do color inpainting. The default is no.\n"
" --ci-radius=<float_number>\n"
" Set color inpainting radius (for ns and telea options only).\n"
" The default is 2.0\n\n"
" -ws=, --wobble-suppress=(yes|no)\n"
" Perform wobble suppression. The default is no.\n"
" --ws-lp=(yes|no)\n"
" Turn on/off LP based motion estimation. The default is no.\n"
" --ws-period=<int_number>\n"
" Set wobble suppression period. The default is 30.\n"
" --ws-model=(transl|transl_and_scale|rigid|similarity|affine|homography)\n"
" Set wobble suppression motion model (must have more DOF than motion \n"
" estimation model). The default is homography.\n"
" --ws-subset=(<int_number>|auto)\n"
" Number of random samples per one motion hypothesis. The default is auto.\n"
" --ws-thresh=(<float_number>|auto)\n"
" Maximum error to classify match as inlier. The default is auto.\n"
" --ws-outlier-ratio=<float_number>\n"
" Motion estimation outlier ratio hypothesis. The default is 0.5.\n"
" --ws-min-inlier-ratio=<float_number>\n"
" Minimum inlier ratio to decide if estimated motion is OK. The default is 0.1.\n"
" --ws-nkps=<int_number>\n"
" Number of keypoints to find in each frame. The default is 1000.\n"
" --ws-local-outlier-rejection=(yes|no)\n"
" Perform local outlier rejection. The default is no.\n\n"
" -sm2=, --save-motions2=(<file_path>|no)\n"
" Save motions estimated for wobble suppression. The default is no.\n"
" -lm2=, --load-motions2=(<file_path>|no)\n"
" Load motions for wobble suppression from file. The default is no.\n\n"
" -gpu=(yes|no)\n"
" Use CUDA optimization whenever possible. The default is no.\n\n"
" -o=, --output=(no|<file_path>)\n"
" Set output file path explicitly. The default is stabilized.avi.\n"
" --fps=(<float_number>|auto)\n"
" Set output video FPS explicitly. By default the source FPS is used (auto).\n"
" -q, --quiet\n"
" Don't show output video frames.\n\n"
" -h, --help\n"
" Print help.\n\n"
"Note: some argument configurations lead to two passes, some to single pass.\n\n";
}
// motion estimator builders are for concise creation of motion estimators
class IMotionEstimatorBuilder
{
public:
virtual ~IMotionEstimatorBuilder() {}
virtual Ptr<ImageMotionEstimatorBase> build() = 0;
protected:
IMotionEstimatorBuilder(CommandLineParser &command) : cmd(command) {}
CommandLineParser cmd;
};
class MotionEstimatorRansacL2Builder : public IMotionEstimatorBuilder
{
public:
MotionEstimatorRansacL2Builder(CommandLineParser &command, bool use_gpu, const string &_prefix = "")
: IMotionEstimatorBuilder(command), gpu(use_gpu), prefix(_prefix) {}
virtual Ptr<ImageMotionEstimatorBase> build() CV_OVERRIDE
{
Ptr<MotionEstimatorRansacL2> est = makePtr<MotionEstimatorRansacL2>(motionModel(arg(prefix + "model")));
RansacParams ransac = est->ransacParams();
if (arg(prefix + "subset") != "auto")
ransac.size = argi(prefix + "subset");
if (arg(prefix + "thresh") != "auto")
ransac.thresh = argf(prefix + "thresh");
ransac.eps = argf(prefix + "outlier-ratio");
est->setRansacParams(ransac);
est->setMinInlierRatio(argf(prefix + "min-inlier-ratio"));
Ptr<IOutlierRejector> outlierRejector = makePtr<NullOutlierRejector>();
if (arg(prefix + "local-outlier-rejection") == "yes")
{
Ptr<TranslationBasedLocalOutlierRejector> tblor = makePtr<TranslationBasedLocalOutlierRejector>();
RansacParams ransacParams = tblor->ransacParams();
if (arg(prefix + "thresh") != "auto")
ransacParams.thresh = argf(prefix + "thresh");
tblor->setRansacParams(ransacParams);
outlierRejector = tblor;
}
#if defined(HAVE_OPENCV_CUDAIMGPROC) && defined(HAVE_OPENCV_CUDAOPTFLOW)
if (gpu)
{
Ptr<KeypointBasedMotionEstimatorGpu> kbest = makePtr<KeypointBasedMotionEstimatorGpu>(est);
kbest->setOutlierRejector(outlierRejector);
return kbest;
}
#else
CV_Assert(gpu == false && "CUDA modules are not available");
#endif
Ptr<KeypointBasedMotionEstimator> kbest = makePtr<KeypointBasedMotionEstimator>(est);
kbest->setDetector(GFTTDetector::create(argi(prefix + "nkps")));
kbest->setOutlierRejector(outlierRejector);
return kbest;
}
private:
bool gpu;
string prefix;
};
class MotionEstimatorL1Builder : public IMotionEstimatorBuilder
{
public:
MotionEstimatorL1Builder(CommandLineParser &command, bool use_gpu, const string &_prefix = "")
: IMotionEstimatorBuilder(command), gpu(use_gpu), prefix(_prefix) {}
virtual Ptr<ImageMotionEstimatorBase> build() CV_OVERRIDE
{
Ptr<MotionEstimatorL1> est = makePtr<MotionEstimatorL1>(motionModel(arg(prefix + "model")));
Ptr<IOutlierRejector> outlierRejector = makePtr<NullOutlierRejector>();
if (arg(prefix + "local-outlier-rejection") == "yes")
{
Ptr<TranslationBasedLocalOutlierRejector> tblor = makePtr<TranslationBasedLocalOutlierRejector>();
RansacParams ransacParams = tblor->ransacParams();
if (arg(prefix + "thresh") != "auto")
ransacParams.thresh = argf(prefix + "thresh");
tblor->setRansacParams(ransacParams);
outlierRejector = tblor;
}
#if defined(HAVE_OPENCV_CUDAIMGPROC) && defined(HAVE_OPENCV_CUDAOPTFLOW)
if (gpu)
{
Ptr<KeypointBasedMotionEstimatorGpu> kbest = makePtr<KeypointBasedMotionEstimatorGpu>(est);
kbest->setOutlierRejector(outlierRejector);
return kbest;
}
#else
CV_Assert(gpu == false && "CUDA modules are not available");
#endif
Ptr<KeypointBasedMotionEstimator> kbest = makePtr<KeypointBasedMotionEstimator>(est);
kbest->setDetector(GFTTDetector::create(argi(prefix + "nkps")));
kbest->setOutlierRejector(outlierRejector);
return kbest;
}
private:
bool gpu;
string prefix;
};
int main(int argc, const char **argv)
{
try
{
const char *keys =
"{ @1 | | }"
"{ m model | affine | }"
"{ lp lin-prog-motion-est | no | }"
"{ subset | auto | }"
"{ thresh | auto | }"
"{ outlier-ratio | 0.5 | }"
"{ min-inlier-ratio | 0.1 | }"
"{ nkps | 1000 | }"
"{ extra-kps | 0 | }"
"{ local-outlier-rejection | no | }"
"{ feature-masks | no | }"
"{ sm save-motions | no | }"
"{ lm load-motions | no | }"
"{ r radius | 15 | }"
"{ stdev | auto | }"
"{ lps lin-prog-stab | no | }"
"{ lps-trim-ratio | auto | }"
"{ lps-w1 | 1 | }"
"{ lps-w2 | 10 | }"
"{ lps-w3 | 100 | }"
"{ lps-w4 | 100 | }"
"{ deblur | no | }"
"{ deblur-sens | 0.1 | }"
"{ et est-trim | yes | }"
"{ t trim-ratio | 0.1 | }"
"{ ic incl-constr | no | }"
"{ bm border-mode | replicate | }"
"{ mosaic | no | }"
"{ ms mosaic-stdev | 10.0 | }"
"{ mi motion-inpaint | no | }"
"{ mi-dist-thresh | 5.0 | }"
"{ ci color-inpaint | no | }"
"{ ci-radius | 2 | }"
"{ ws wobble-suppress | no | }"
"{ ws-period | 30 | }"
"{ ws-model | homography | }"
"{ ws-subset | auto | }"
"{ ws-thresh | auto | }"
"{ ws-outlier-ratio | 0.5 | }"
"{ ws-min-inlier-ratio | 0.1 | }"
"{ ws-nkps | 1000 | }"
"{ ws-extra-kps | 0 | }"
"{ ws-local-outlier-rejection | no | }"
"{ ws-lp | no | }"
"{ sm2 save-motions2 | no | }"
"{ lm2 load-motions2 | no | }"
"{ gpu | no | }"
"{ o output | stabilized.avi | }"
"{ fps | auto | }"
"{ q quiet | | }"
"{ h help | | }";
CommandLineParser cmd(argc, argv, keys);
// parse command arguments
if (argb("help"))
{
printHelp();
return 0;
}
if (arg("gpu") == "yes")
{
cout << "initializing GPU..."; cout.flush();
Mat hostTmp = Mat::zeros(1, 1, CV_32F);
cuda::GpuMat deviceTmp;
deviceTmp.upload(hostTmp);
cout << endl;
}
StabilizerBase *stabilizer = 0;
// check if source video is specified
string inputPath = arg(0);
if (inputPath.empty())
throw runtime_error("specify video file path");
// get source video parameters
Ptr<VideoFileSource> source = makePtr<VideoFileSource>(inputPath);
cout << "frame count (rough): " << source->count() << endl;
if (arg("fps") == "auto")
outputFps = source->fps();
else
outputFps = argd("fps");
// prepare motion estimation builders
Ptr<IMotionEstimatorBuilder> motionEstBuilder;
if (arg("lin-prog-motion-est") == "yes")
motionEstBuilder.reset(new MotionEstimatorL1Builder(cmd, arg("gpu") == "yes"));
else
motionEstBuilder.reset(new MotionEstimatorRansacL2Builder(cmd, arg("gpu") == "yes"));
Ptr<IMotionEstimatorBuilder> wsMotionEstBuilder;
if (arg("ws-lp") == "yes")
wsMotionEstBuilder.reset(new MotionEstimatorL1Builder(cmd, arg("gpu") == "yes", "ws-"));
else
wsMotionEstBuilder.reset(new MotionEstimatorRansacL2Builder(cmd, arg("gpu") == "yes", "ws-"));
// determine whether we must use one pass or two pass stabilizer
bool isTwoPass =
arg("est-trim") == "yes" || arg("wobble-suppress") == "yes" || arg("lin-prog-stab") == "yes";
if (isTwoPass)
{
// we must use two pass stabilizer
TwoPassStabilizer *twoPassStabilizer = new TwoPassStabilizer();
stabilizer = twoPassStabilizer;
twoPassStabilizer->setEstimateTrimRatio(arg("est-trim") == "yes");
// determine stabilization technique
if (arg("lin-prog-stab") == "yes")
{
Ptr<LpMotionStabilizer> stab = makePtr<LpMotionStabilizer>();
stab->setFrameSize(Size(source->width(), source->height()));
stab->setTrimRatio(arg("lps-trim-ratio") == "auto" ? argf("trim-ratio") : argf("lps-trim-ratio"));
stab->setWeight1(argf("lps-w1"));
stab->setWeight2(argf("lps-w2"));
stab->setWeight3(argf("lps-w3"));
stab->setWeight4(argf("lps-w4"));
twoPassStabilizer->setMotionStabilizer(stab);
}
else if (arg("stdev") == "auto")
twoPassStabilizer->setMotionStabilizer(makePtr<GaussianMotionFilter>(argi("radius")));
else
twoPassStabilizer->setMotionStabilizer(makePtr<GaussianMotionFilter>(argi("radius"), argf("stdev")));
// init wobble suppressor if necessary
if (arg("wobble-suppress") == "yes")
{
Ptr<MoreAccurateMotionWobbleSuppressorBase> ws = makePtr<MoreAccurateMotionWobbleSuppressor>();
if (arg("gpu") == "yes")
#ifdef HAVE_OPENCV_CUDAWARPING
ws = makePtr<MoreAccurateMotionWobbleSuppressorGpu>();
#else
throw runtime_error("OpenCV is built without CUDA support");
#endif
ws->setMotionEstimator(wsMotionEstBuilder->build());
ws->setPeriod(argi("ws-period"));
twoPassStabilizer->setWobbleSuppressor(ws);
MotionModel model = ws->motionEstimator()->motionModel();
if (arg("load-motions2") != "no")
{
ws->setMotionEstimator(makePtr<FromFileMotionReader>(arg("load-motions2")));
ws->motionEstimator()->setMotionModel(model);
}
if (arg("save-motions2") != "no")
{
ws->setMotionEstimator(makePtr<ToFileMotionWriter>(arg("save-motions2"), ws->motionEstimator()));
ws->motionEstimator()->setMotionModel(model);
}
}
}
else
{
// we must use one pass stabilizer
OnePassStabilizer *onePassStabilizer = new OnePassStabilizer();
stabilizer = onePassStabilizer;
if (arg("stdev") == "auto")
onePassStabilizer->setMotionFilter(makePtr<GaussianMotionFilter>(argi("radius")));
else
onePassStabilizer->setMotionFilter(makePtr<GaussianMotionFilter>(argi("radius"), argf("stdev")));
}
stabilizer->setFrameSource(source);
stabilizer->setMotionEstimator(motionEstBuilder->build());
if (arg("feature-masks") != "no")
{
Ptr<MaskFrameSource> maskSource = makePtr<MaskFrameSource>(
makePtr<VideoFileSource>(arg("feature-masks")));
std::function<void(Mat&)> maskCallback = [](Mat & inputFrame)
{
cv::cvtColor(inputFrame, inputFrame, cv::COLOR_BGR2GRAY);
threshold(inputFrame, inputFrame, 127, 255, THRESH_BINARY);
};
maskSource->setMaskCallback(maskCallback);
stabilizer->setMaskSource(maskSource);
}
// cast stabilizer to simple frame source interface to read stabilized frames
stabilizedFrames.reset(dynamic_cast<IFrameSource*>(stabilizer));
MotionModel model = stabilizer->motionEstimator()->motionModel();
if (arg("load-motions") != "no")
{
stabilizer->setMotionEstimator(makePtr<FromFileMotionReader>(arg("load-motions")));
stabilizer->motionEstimator()->setMotionModel(model);
}
if (arg("save-motions") != "no")
{
stabilizer->setMotionEstimator(makePtr<ToFileMotionWriter>(arg("save-motions"), stabilizer->motionEstimator()));
stabilizer->motionEstimator()->setMotionModel(model);
}
stabilizer->setRadius(argi("radius"));
// init deblurer
if (arg("deblur") == "yes")
{
Ptr<WeightingDeblurer> deblurer = makePtr<WeightingDeblurer>();
deblurer->setRadius(argi("radius"));
deblurer->setSensitivity(argf("deblur-sens"));
stabilizer->setDeblurer(deblurer);
}
// set up trimming parameters
stabilizer->setTrimRatio(argf("trim-ratio"));
stabilizer->setCorrectionForInclusion(arg("incl-constr") == "yes");
if (arg("border-mode") == "reflect")
stabilizer->setBorderMode(BORDER_REFLECT);
else if (arg("border-mode") == "replicate")
stabilizer->setBorderMode(BORDER_REPLICATE);
else if (arg("border-mode") == "const")
stabilizer->setBorderMode(BORDER_CONSTANT);
else
throw runtime_error("unknown border extrapolation mode: "
+ cmd.get<string>("border-mode"));
// init inpainter
InpaintingPipeline *inpainters = new InpaintingPipeline();
Ptr<InpainterBase> inpainters_(inpainters);
if (arg("mosaic") == "yes")
{
Ptr<ConsistentMosaicInpainter> inp = makePtr<ConsistentMosaicInpainter>();
inp->setStdevThresh(argf("mosaic-stdev"));
inpainters->pushBack(inp);
}
if (arg("motion-inpaint") == "yes")
{
Ptr<MotionInpainter> inp = makePtr<MotionInpainter>();
inp->setDistThreshold(argf("mi-dist-thresh"));
inpainters->pushBack(inp);
}
if (arg("color-inpaint") == "average")
inpainters->pushBack(makePtr<ColorAverageInpainter>());
else if (arg("color-inpaint") == "ns")
inpainters->pushBack(makePtr<ColorInpainter>(int(INPAINT_NS), argd("ci-radius")));
else if (arg("color-inpaint") == "telea")
inpainters->pushBack(makePtr<ColorInpainter>(int(INPAINT_TELEA), argd("ci-radius")));
else if (arg("color-inpaint") != "no")
throw runtime_error("unknown color inpainting method: " + arg("color-inpaint"));
if (!inpainters->empty())
{
inpainters->setRadius(argi("radius"));
stabilizer->setInpainter(inpainters_);
}
if (arg("output") != "no")
outputPath = arg("output");
quietMode = argb("quiet");
run();
}
catch (const exception &e)
{
cout << "error: " << e.what() << endl;
stabilizedFrames.release();
return -1;
}
stabilizedFrames.release();
return 0;
}
MotionModel motionModel(const string &str)
{
if (str == "transl")
return MM_TRANSLATION;
if (str == "transl_and_scale")
return MM_TRANSLATION_AND_SCALE;
if (str == "rigid")
return MM_RIGID;
if (str == "similarity")
return MM_SIMILARITY;
if (str == "affine")
return MM_AFFINE;
if (str == "homography")
return MM_HOMOGRAPHY;
throw runtime_error("unknown motion model: " + str);
}
| 42.036021 | 124 | 0.540907 | Kriston-SCT |
3708613729c793f8c46cbf6bf09d74e2cc8949b1 | 2,622 | cpp | C++ | src/Conversion/SeqToMemref/KrnlSeqStore.cpp | philass/onnx-mlir | 09965003137f82d8891676c986ec6403faa9c3cb | [
"Apache-2.0"
] | 1 | 2022-03-23T06:41:14.000Z | 2022-03-23T06:41:14.000Z | src/Conversion/SeqToMemref/KrnlSeqStore.cpp | philass/onnx-mlir | 09965003137f82d8891676c986ec6403faa9c3cb | [
"Apache-2.0"
] | 1 | 2022-03-31T23:58:31.000Z | 2022-03-31T23:58:31.000Z | src/Conversion/SeqToMemref/KrnlSeqStore.cpp | philass/onnx-mlir | 09965003137f82d8891676c986ec6403faa9c3cb | [
"Apache-2.0"
] | null | null | null | /*
* SPDX-License-Identifier: Apache-2.0
*/
//===------ KrnlSeqStore.cpp - Lower KrnlSeqStoreOp ----------------------===//
//
// Copyright 2019-2022 The IBM Research Authors.
//
// =============================================================================
//
// This file lowers the KrnlSeqStoreOp operator.
//
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "src/Conversion/KrnlToLLVM/KrnlToLLVMHelper.hpp"
#include "src/Dialect/Krnl/KrnlHelper.hpp"
#include "src/Dialect/Krnl/KrnlOps.hpp"
#include "llvm/Support/Debug.h"
#define DEBUG_TYPE "krnl_to_llvm"
using namespace mlir;
using namespace onnx_mlir;
namespace onnx_mlir {
namespace krnl {
class KrnlSeqStoreOpLowering : public ConversionPattern {
public:
explicit KrnlSeqStoreOpLowering(
TypeConverter &typeConverter, MLIRContext *context)
: ConversionPattern(
typeConverter, KrnlSeqStoreOp::getOperationName(), 1, context) {}
LogicalResult matchAndRewrite(Operation *op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override {
KrnlSeqStoreOpAdaptor operandAdaptor(operands);
auto loc = op->getLoc();
MultiDialectBuilder<MathBuilder, MemRefBuilder> create(rewriter, loc);
// Allocate a new tensor and copy input tensor into it
auto inputType = operandAdaptor.input().getType().cast<MemRefType>();
SmallVector<mlir::Value, 4> allocParams;
for (size_t i = 0; i < inputType.getShape().size(); i++) {
if (inputType.getShape()[i] == -1) {
allocParams.emplace_back(create.mem.dim(operandAdaptor.input(), i));
}
}
Value alloc = create.mem.alignedAlloc(inputType, allocParams);
rewriter.create<memref::CopyOp>(loc, operandAdaptor.input(), alloc);
// Cast the input tensor to the element type of the sequence
auto seq = operandAdaptor.seq();
auto seqElementType =
seq.getType().cast<MemRefType>().getElementType().cast<MemRefType>();
auto casted = create.mem.cast(alloc, seqElementType);
// Store the tensor
rewriter.create<memref::StoreOp>(loc, casted, seq, operandAdaptor.index());
rewriter.eraseOp(op);
return success();
}
};
void populateLoweringKrnlSeqStoreOpPattern(TypeConverter &typeConverter,
RewritePatternSet &patterns, MLIRContext *ctx) {
patterns.insert<KrnlSeqStoreOpLowering>(typeConverter, ctx);
}
} // namespace krnl
} // namespace onnx_mlir
| 34.051948 | 80 | 0.673913 | philass |
370a1b6d2d4bccf45fe401b1685cee1054ff769f | 28,376 | cpp | C++ | wrappers/Modelica/src/coolpropsolver.cpp | friederikeboehm/CoolProp | 44325d9e6abd9e6f88f428720f4f64a0c1962784 | [
"MIT"
] | null | null | null | wrappers/Modelica/src/coolpropsolver.cpp | friederikeboehm/CoolProp | 44325d9e6abd9e6f88f428720f4f64a0c1962784 | [
"MIT"
] | null | null | null | wrappers/Modelica/src/coolpropsolver.cpp | friederikeboehm/CoolProp | 44325d9e6abd9e6f88f428720f4f64a0c1962784 | [
"MIT"
] | null | null | null | #include "coolpropsolver.h"
#include "CoolPropTools.h"
#include "CoolProp.h"
#include "CPState.h"
#include <iostream>
#include <string>
#include <stdlib.h>
CoolPropSolver::CoolPropSolver(const std::string& mediumName, const std::string& libraryName, const std::string& substanceName)
: BaseSolver(mediumName, libraryName, substanceName) {
// Fluid name can be used to pass in other parameters.
// The string can be composed like "Propane|enable_TTSE=1|calc_transport=0"
std::vector<std::string> name_options = strsplit(substanceName, '|');
// Set the defaults
fluidType = -1;
enable_TTSE = false;
debug_level = 0;
calc_transport = false;
extend_twophase = false;
twophase_derivsmoothing_xend = 0;
rho_smoothing_xend = 0;
if (name_options.size() > 1) {
for (unsigned int i = 1; i < name_options.size(); i++) {
// Split around the equals sign
std::vector<std::string> param_val = strsplit(name_options[i], '=');
if (param_val.size() != 2) {
errorMessage((char*)format("Could not parse the option [%s], must be in the form param=value", name_options[i].c_str()).c_str());
}
// Check each of the options in turn
if (!param_val[0].compare("enable_TTSE")) {
if (!param_val[1].compare("1") || !param_val[1].compare("true")) {
std::cout << "TTSE is on\n";
enable_TTSE = true;
} else if (!param_val[1].compare("0") || !param_val[1].compare("false")) {
std::cout << "TTSE is off\n";
enable_TTSE = false;
} else
errorMessage((char*)format("I don't know how to handle this option [%s]", name_options[i].c_str()).c_str());
//throw NotImplementedError((char*)format("I don't know how to handle this option [%s]",name_options[i].c_str()).c_str());
} else if (!param_val[0].compare("calc_transport")) {
if (!param_val[1].compare("1") || !param_val[1].compare("true"))
calc_transport = true;
else if (!param_val[1].compare("0") || !param_val[1].compare("false"))
calc_transport = false;
else
errorMessage((char*)format("I don't know how to handle this option [%s]", name_options[i].c_str()).c_str());
} else if (!param_val[0].compare("enable_EXTTP")) {
if (!param_val[1].compare("1") || !param_val[1].compare("true"))
extend_twophase = true;
else if (!param_val[1].compare("0") || !param_val[1].compare("false"))
extend_twophase = false;
else
errorMessage((char*)format("I don't know how to handle this option [%s]", name_options[i].c_str()).c_str());
} else if (!param_val[0].compare("twophase_derivsmoothing_xend")) {
twophase_derivsmoothing_xend = strtod(param_val[1].c_str(), NULL);
if (twophase_derivsmoothing_xend < 0 || twophase_derivsmoothing_xend > 1)
errorMessage(
(char*)format("I don't know how to handle this twophase_derivsmoothing_xend value [%d]", param_val[0].c_str()).c_str());
} else if (!param_val[0].compare("rho_smoothing_xend")) {
rho_smoothing_xend = strtod(param_val[1].c_str(), NULL);
if (rho_smoothing_xend < 0 || rho_smoothing_xend > 1)
errorMessage((char*)format("I don't know how to handle this rho_smoothing_xend value [%d]", param_val[0].c_str()).c_str());
} else if (!param_val[0].compare("debug")) {
debug_level = (int)strtol(param_val[1].c_str(), NULL, 0);
if (debug_level < 0 || debug_level > 1000)
errorMessage((char*)format("I don't know how to handle this debug level [%s]", param_val[0].c_str()).c_str());
} else {
errorMessage((char*)format("This option [%s] was not understood", name_options[i].c_str()).c_str());
}
// Some options were passed in, lets see what we have
std::cout << param_val[0] << " has the value of " << param_val[1] << std::endl;
}
}
// Handle the name and fill the fluid type
if (debug_level > 5) std::cout << "Checking fluid " << name_options[0] << " against database." << std::endl;
fluidType = getFluidType(name_options[0]); // Throws an error if unknown fluid
if (debug_level > 5) std::cout << "Check passed, reducing " << substanceName << " to " << name_options[0] << std::endl;
this->substanceName = name_options[0];
state = new CoolPropStateClassSI(name_options[0]);
setFluidConstants();
}
void CoolPropSolver::setFluidConstants() {
if ((fluidType == FLUID_TYPE_PURE) || (fluidType == FLUID_TYPE_PSEUDOPURE) || (fluidType == FLUID_TYPE_REFPROP)) {
if (debug_level > 5) std::cout << format("Setting constants for fluid %s \n", substanceName.c_str());
_fluidConstants.pc = PropsSI((char*)"pcrit", (char*)"T", 0, (char*)"P", 0, (char*)substanceName.c_str());
_fluidConstants.Tc = PropsSI((char*)"Tcrit", (char*)"T", 0, (char*)"P", 0, (char*)substanceName.c_str());
_fluidConstants.MM = PropsSI((char*)"molemass", (char*)"T", 0, (char*)"P", 0, (char*)substanceName.c_str());
_fluidConstants.dc = PropsSI((char*)"rhocrit", (char*)"T", 0, (char*)"P", 0, (char*)substanceName.c_str());
return;
}
if ((fluidType == FLUID_TYPE_INCOMPRESSIBLE_LIQUID) || (fluidType == FLUID_TYPE_INCOMPRESSIBLE_SOLUTION)) {
if (debug_level > 5) std::cout << format("Setting constants for incompressible fluid %s \n", substanceName.c_str());
_fluidConstants.pc = -1;
_fluidConstants.Tc = -1;
_fluidConstants.MM = -1;
_fluidConstants.dc = -1;
return;
}
}
void CoolPropSolver::preStateChange(void) {
/// Some common code to avoid pitfalls from incompressibles
if ((fluidType == FLUID_TYPE_PURE) || (fluidType == FLUID_TYPE_PSEUDOPURE) || (fluidType == FLUID_TYPE_REFPROP)) {
try {
if (enable_TTSE)
state->enable_TTSE_LUT();
else
state->disable_TTSE_LUT();
if (extend_twophase)
state->enable_EXTTP();
else
state->disable_EXTTP();
} catch (std::exception& e) {
errorMessage((char*)e.what());
std::cout << format("Exception from state object: %s \n", (char*)e.what());
}
}
}
void CoolPropSolver::postStateChange(ExternalThermodynamicState* const properties) {
/// Some common code to avoid pitfalls from incompressibles
switch (fluidType) {
case FLUID_TYPE_PURE:
case FLUID_TYPE_PSEUDOPURE:
case FLUID_TYPE_REFPROP:
try {
// Set the values in the output structure
properties->p = state->p();
properties->T = state->T();
properties->d = state->rho();
properties->h = state->h();
properties->s = state->s();
if (state->TwoPhase) {
properties->phase = 2;
} else {
properties->phase = 1;
}
properties->cp = state->cp();
properties->cv = state->cv();
properties->a = state->speed_sound();
if (state->TwoPhase && state->Q() >= 0 && state->Q() <= twophase_derivsmoothing_xend) {
// Use the smoothed derivatives between a quality of 0 and twophase_derivsmoothing_xend
properties->ddhp = state->drhodh_constp_smoothed(twophase_derivsmoothing_xend); // [1/kPa -- > 1/Pa]
properties->ddph = state->drhodp_consth_smoothed(twophase_derivsmoothing_xend); // [1/(kJ/kg) -- > 1/(J/kg)]
} else if (state->TwoPhase && state->Q() >= 0 && state->Q() <= rho_smoothing_xend) {
// Use the smoothed density between a quality of 0 and rho_smoothing_xend
double rho_spline;
double dsplinedh;
double dsplinedp;
state->rho_smoothed(rho_smoothing_xend, rho_spline, dsplinedh, dsplinedp);
properties->ddhp = dsplinedh;
properties->ddph = dsplinedp;
properties->d = rho_spline;
} else {
properties->ddhp = state->drhodh_constp();
properties->ddph = state->drhodp_consth();
}
properties->kappa = state->isothermal_compressibility();
properties->beta = state->isobaric_expansion_coefficient();
if (calc_transport) {
properties->eta = state->viscosity();
properties->lambda = state->conductivity(); //[kW/m/K --> W/m/K]
} else {
properties->eta = -_HUGE;
properties->lambda = -_HUGE;
}
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
break;
case FLUID_TYPE_INCOMPRESSIBLE_LIQUID:
case FLUID_TYPE_INCOMPRESSIBLE_SOLUTION:
try {
// Set the values in the output structure
properties->p = state->p();
properties->T = state->T();
properties->d = state->rho();
properties->h = state->h();
properties->s = state->s();
properties->phase = 1;
properties->cp = state->cp();
properties->cv = state->cv();
properties->a = -_HUGE;
properties->ddhp = state->drhodh_constp();
properties->ddph = 0.0; // TODO: Fix this
properties->kappa = -_HUGE;
properties->beta = -_HUGE;
if (calc_transport) {
properties->eta = state->viscosity();
properties->lambda = state->conductivity(); //[kW/m/K --> W/m/K]
} else {
properties->eta = -_HUGE;
properties->lambda = -_HUGE;
}
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
break;
default:
errorMessage((char*)"Invalid fluid type!");
break;
}
}
void CoolPropSolver::setSat_p(double& p, ExternalSaturationProperties* const properties) {
if (debug_level > 5) std::cout << format("setSat_p(%0.16e)\n", p);
this->preStateChange();
try {
state->update(iP, p, iQ, 0); // quality only matters for pseudo-pure fluids
//! Saturation temperature
properties->Tsat = state->TL(); // Not correct for pseudo-pure fluids
//! Derivative of Ts wrt pressure
properties->dTp = state->dTdp_along_sat();
//! Derivative of dls wrt pressure
properties->ddldp = state->drhodp_along_sat_liquid();
//! Derivative of dvs wrt pressure
properties->ddvdp = state->drhodp_along_sat_vapor();
//! Derivative of hls wrt pressure
properties->dhldp = state->dhdp_along_sat_liquid();
//! Derivative of hvs wrt pressure
properties->dhvdp = state->dhdp_along_sat_vapor();
//! Density at bubble line (for pressure ps)
properties->dl = state->rhoL();
//! Density at dew line (for pressure ps)
properties->dv = state->rhoV();
//! Specific enthalpy at bubble line (for pressure ps)
properties->hl = state->hL();
//! Specific enthalpy at dew line (for pressure ps)
properties->hv = state->hV();
//! Saturation pressure
properties->psat = p;
//! Surface tension
properties->sigma = state->surface_tension();
//! Specific entropy at bubble line (for pressure ps)
properties->sl = state->sL();
//! Specific entropy at dew line (for pressure ps)
properties->sv = state->sV();
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
void CoolPropSolver::setSat_T(double& T, ExternalSaturationProperties* const properties) {
if (debug_level > 5) std::cout << format("setSat_T(%0.16e)\n", T);
this->preStateChange();
try {
state->update(iT, T, iQ, 0); // Quality only matters for pseudo-pure fluids
properties->Tsat = T;
properties->psat = state->p();
properties->dl = state->rhoL();
properties->dv = state->rhoV();
properties->hl = state->hL();
properties->hv = state->hV();
properties->dTp = state->dTdp_along_sat();
properties->ddldp = state->drhodp_along_sat_liquid();
properties->ddvdp = state->drhodp_along_sat_vapor();
properties->dhldp = state->dhdp_along_sat_liquid();
properties->dhvdp = state->dhdp_along_sat_vapor();
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
// Note: the phase input is currently not supported
void CoolPropSolver::setState_ph(double& p, double& h, int& phase, ExternalThermodynamicState* const properties) {
if (debug_level > 5) std::cout << format("setState_ph(p=%0.16e,h=%0.16e)\n", p, h);
this->preStateChange();
try {
// Update the internal variables in the state instance
state->update(iP, p, iH, h);
if (!ValidNumber(state->rho()) || !ValidNumber(state->T())) {
throw ValueError(format("p-h [%g, %g] failed for update", p, h));
}
// Set the values in the output structure
this->postStateChange(properties);
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
void CoolPropSolver::setState_pT(double& p, double& T, ExternalThermodynamicState* const properties) {
if (debug_level > 5) std::cout << format("setState_pT(p=%0.16e,T=%0.16e)\n", p, T);
this->preStateChange();
try {
// Update the internal variables in the state instance
state->update(iP, p, iT, T);
// Set the values in the output structure
this->postStateChange(properties);
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
// Note: the phase input is currently not supported
void CoolPropSolver::setState_dT(double& d, double& T, int& phase, ExternalThermodynamicState* const properties) {
if (debug_level > 5) std::cout << format("setState_dT(d=%0.16e,T=%0.16e)\n", d, T);
this->preStateChange();
try {
// Update the internal variables in the state instance
state->update(iD, d, iT, T);
// Set the values in the output structure
this->postStateChange(properties);
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
// Note: the phase input is currently not supported
void CoolPropSolver::setState_ps(double& p, double& s, int& phase, ExternalThermodynamicState* const properties) {
if (debug_level > 5) std::cout << format("setState_ps(p=%0.16e,s=%0.16e)\n", p, s);
this->preStateChange();
try {
// Update the internal variables in the state instance
state->update(iP, p, iS, s);
// Set the values in the output structure
this->postStateChange(properties);
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
// Note: the phase input is currently not supported
void CoolPropSolver::setState_hs(double& h, double& s, int& phase, ExternalThermodynamicState* const properties) {
if (debug_level > 5) std::cout << format("setState_hs(h=%0.16e,s=%0.16e)\n", h, s);
this->preStateChange();
try {
// Update the internal variables in the state instance
state->update(iH, h, iS, s);
// Set the values in the output structure
this->postStateChange(properties);
} catch (std::exception& e) {
errorMessage((char*)e.what());
}
}
double CoolPropSolver::Pr(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: Pr() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: Pr() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::T(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: T() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: T() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::a(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: a() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: a() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::beta(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: beta() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: beta() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::cp(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: cp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: cp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::cv(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: cv() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: cv() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::d(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: d() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: d() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::ddhp(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: ddhp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: ddhp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::ddph(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: ddph() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: ddph() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::eta(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: eta() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: eta() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::h(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: h() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: h() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::kappa(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: kappa() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: kappa() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::lambda(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: lambda() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: lambda() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::p(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: p() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: p() not implemented in the Solver object");
return -_HUGE;
}
int CoolPropSolver::phase(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: phase() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: phase() not implemented in the Solver object");
return -1;
}
double CoolPropSolver::s(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: s() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: s() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::d_der(ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: d_der() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: d_der() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::isentropicEnthalpy(double& p, ExternalThermodynamicState* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: isentropicEnthalpy() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: isentropicEnthalpy() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::dTp(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: dTp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: dTp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::ddldp(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: ddldp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: ddldp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::ddvdp(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: ddvdp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: ddvdp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::dhldp(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: dhldp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: dhldp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::dhvdp(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: dhvdp() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: dhvdp() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::dl(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: dl() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: dl() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::dv(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: dv() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: dv() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::hl(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: hl() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: hl() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::hv(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: hv() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: hv() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::sigma(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: sigma() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: sigma() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::sl(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: sl() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: sl() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::sv(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: sv() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: sv() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::psat(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: psat() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: psat() not implemented in the Solver object");
return -_HUGE;
}
double CoolPropSolver::Tsat(ExternalSaturationProperties* const properties) {
// Base function returns an error if called - should be redeclared by the solver object
errorMessage((char*)"Internal error: Tsat() not implemented in the Solver object");
//throw NotImplementedError((char*)"Internal error: Tsat() not implemented in the Solver object");
return -_HUGE;
}
| 47.451505 | 145 | 0.646673 | friederikeboehm |
371484c32adb41d06fec45db2cc24a093f1875b0 | 4,009 | cpp | C++ | src/ros_tutorials/roscpp_tutorials/custom_callback_processing/custom_callback_processing.cpp | duken72/ros2wsTest | 4fa8f7aaf9ec8e70a8b6d7554ced373300a38a71 | [
"MIT"
] | 742 | 2017-07-05T02:49:36.000Z | 2022-03-30T12:55:43.000Z | src/ros_tutorials/roscpp_tutorials/custom_callback_processing/custom_callback_processing.cpp | duken72/ros2wsTest | 4fa8f7aaf9ec8e70a8b6d7554ced373300a38a71 | [
"MIT"
] | 73 | 2017-07-06T12:50:51.000Z | 2022-03-07T08:07:07.000Z | src/ros_tutorials/roscpp_tutorials/custom_callback_processing/custom_callback_processing.cpp | duken72/ros2wsTest | 4fa8f7aaf9ec8e70a8b6d7554ced373300a38a71 | [
"MIT"
] | 425 | 2017-07-04T22:03:29.000Z | 2022-03-29T06:59:06.000Z | /*
* Copyright (C) 2009, Willow Garage, Inc.
*
* 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 names of Stanford University or Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "ros/ros.h"
#include "ros/callback_queue.h"
#include "std_msgs/String.h"
#include <boost/thread.hpp>
/**
* This tutorial demonstrates the use of custom separate callback queues that can be processed
* independently, whether in different threads or just at different times.
*/
/**
* This callback gets called from the main queue processed in spin()
*/
void chatterCallbackMainQueue(const std_msgs::String::ConstPtr& msg)
{
ROS_INFO_STREAM("I heard: [ " << msg->data << "] in thread [" << boost::this_thread::get_id() << "] (Main thread)");
}
/**
* This callback gets called from the custom queue
*/
void chatterCallbackCustomQueue(const std_msgs::String::ConstPtr& msg)
{
ROS_INFO_STREAM("I heard: [ " << msg->data << "] in thread [" << boost::this_thread::get_id() << "]");
}
/**
* The custom queue used for one of the subscription callbacks
*/
ros::CallbackQueue g_queue;
void callbackThread()
{
ROS_INFO_STREAM("Callback thread id=" << boost::this_thread::get_id());
ros::NodeHandle n;
while (n.ok())
{
g_queue.callAvailable(ros::WallDuration(0.01));
}
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "listener_with_custom_callback_processing");
ros::NodeHandle n;
/**
* The SubscribeOptions structure lets you specify a custom queue to use for a specific subscription.
* You can also set a default queue on a NodeHandle using the NodeHandle::setCallbackQueue() function.
*
* AdvertiseOptions and AdvertiseServiceOptions offer similar functionality.
*/
ros::SubscribeOptions ops = ros::SubscribeOptions::create<std_msgs::String>("chatter", 1000,
chatterCallbackCustomQueue,
ros::VoidPtr(), &g_queue);
ros::Subscriber sub = n.subscribe(ops);
/**
* Now we subscribe using the normal method, to demonstrate the difference.
*/
ros::Subscriber sub2 = n.subscribe("chatter", 1000, chatterCallbackMainQueue);
/**
* Start a thread to service the custom queue
*/
boost::thread chatter_thread(callbackThread);
ROS_INFO_STREAM("Main thread id=" << boost::this_thread::get_id());
/**
* Now do a custom spin, to demonstrate the difference.
*/
ros::Rate r(1);
while (n.ok())
{
ros::spinOnce();
r.sleep();
}
chatter_thread.join();
return 0;
}
| 36.117117 | 118 | 0.694936 | duken72 |
37165a40dad2e0075a25d5412d3e053e86f06868 | 12,830 | cpp | C++ | QtRPT-Example/QtRptProject/QtRptDesigner/TContainerLine.cpp | salim97/QtRPT | 0bb1cb7e2c8d5c638f53092625b00bb608d9ede3 | [
"MIT"
] | null | null | null | QtRPT-Example/QtRptProject/QtRptDesigner/TContainerLine.cpp | salim97/QtRPT | 0bb1cb7e2c8d5c638f53092625b00bb608d9ede3 | [
"MIT"
] | null | null | null | QtRPT-Example/QtRptProject/QtRptDesigner/TContainerLine.cpp | salim97/QtRPT | 0bb1cb7e2c8d5c638f53092625b00bb608d9ede3 | [
"MIT"
] | 3 | 2019-12-23T12:51:20.000Z | 2022-03-17T03:36:53.000Z | /*
Name: QtRpt
Version: 1.5.5
Web-site: http://www.qtrpt.tk
Programmer: Aleksey Osipov
E-mail: [email protected]
Web-site: http://www.aliks-os.tk
Copyright 2012-2015 Aleksey Osipov
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 "TContainerLine.h"
#include "ReportBand.h"
TContainerLine::TContainerLine(QWidget *parent, QPoint p, QWidget *cWidget) : RptContainer(parent,p,cWidget) {
QString stl = "TContainerLine#lbl {;"
"border-width:1px;"
"border-style:solid;"
"border-color:rgba(0,0,0,255);"
"border-top-color:rgba(0,0,0,255);"
"border-left-color:rgba(0,0,0,255);"
"border-right-color:rgba(0,0,0,255);"
"border-bottom-color:rgba(0,0,0,255);"
"color:rgba(0,0,0,255);"
"background-color:rgba(255,255,255,0);"
"}";
cs = 0;
ce = 0;
m_arrowStart = false;
m_arrowEnd = true;
this->setStyleSheet(stl);
this->resize(10,10);
this->setBaseSize(width(),height());
this->allowResize(false);
this->allowDrawSelection(false);
this->setAutoFillBackground(true);
this->move(-50,-50);
line.setP1( QPoint() );
line.setP2( QPoint() );
QPalette Pal(palette());
Pal.setColor(QPalette::Background, Qt::blue);
cs = new XYZContainer(parent,QPoint(line.p1().x(), line.p2().y()));
cs->setObjectName("CS");
cs->resize(6,6);
cs->allowResize(false);
cs->allowDrawSelection(false);
cs->setVisible(false);
cs->setAutoFillBackground(true);
cs->setPalette(Pal);
ce = new XYZContainer(parent,QPoint(line.p2().x(), line.p2().y()));
ce->setObjectName("CE");
ce->resize(6,6);
ce->allowResize(false);
ce->allowDrawSelection(false);
ce->setVisible(false);
ce->setAutoFillBackground(true);
ce->setPalette(Pal);
QObject::connect(cs, SIGNAL(newGeometry(QRect, QRect)), this, SIGNAL(newGeometry(QRect, QRect)));
QObject::connect(ce, SIGNAL(newGeometry(QRect, QRect)), this, SIGNAL(newGeometry(QRect, QRect)));
QObject::connect(ce, SIGNAL(newGeometry(QRect, QRect)), this, SLOT(lineChanged(QRect, QRect)));
QObject::connect(cs, SIGNAL(newGeometry(QRect, QRect)), this, SLOT(lineChanged(QRect, QRect)));
//QObject::connect(cs, SIGNAL(geomChanged(QRect, QRect)), this, SIGNAL(geomChanged(QRect, QRect)));
//QObject::connect(ce, SIGNAL(geomChanged(QRect, QRect)), this, SIGNAL(geomChanged(QRect, QRect)));
QObject::connect(cs, SIGNAL(geomChanged(QRect, QRect)), this, SLOT(geomContChanged(QRect, QRect)));
QObject::connect(ce, SIGNAL(geomChanged(QRect, QRect)), this, SLOT(geomContChanged(QRect, QRect)));
QObject::connect(cs, SIGNAL(destroyed()), this, SLOT(delItemInTree()));
QObject::connect(ce, SIGNAL(destroyed()), this, SLOT(delItemInTree()));
QObject::connect(this, SIGNAL(delCont(QTreeWidgetItem *)), this, SLOT(delItemInTree()));
QObject::connect(cs, SIGNAL(inFocus(bool)), this, SLOT(m_inFocus(bool)));
QObject::connect(ce, SIGNAL(inFocus(bool)), this, SLOT(m_inFocus(bool)));
//QObject::connect(this, SIGNAL(inFocus(bool)), cs, SIGNAL(inFocus(bool)));
//QObject::connect(this, SIGNAL(inFocus(bool)), ce, SIGNAL(inFocus(bool)));
this->show();
}
void TContainerLine::geomContChanged(QRect oldRect, QRect newRect) {
if (sender() == cs) {
m_oldP1 = oldRect;
m_oldP2 = ce->geometry();
}
if (sender() == ce) {
m_oldP1 = cs->geometry();
m_oldP2 = oldRect;
}
emit geomChanged(oldRect,newRect);
}
void TContainerLine::delItemInTree() {
delete this;
}
void TContainerLine::setArrow(Command command, QVariant value) {
if (command == ArrowStart)
m_arrowStart = value.toBool();
if (command ==ArrowEnd)
m_arrowEnd = value.toBool();
this->parentWidget()->repaint();
}
bool TContainerLine::getArrow(Command command) {
bool result = false;
if (command == ArrowStart)
result = m_arrowStart;
if (command ==ArrowEnd)
result = m_arrowEnd;
return result;
}
void TContainerLine::focusInEvent(QFocusEvent *e) {
XYZContainer::focusInEvent(e);
setLine(true);
}
void TContainerLine::focusOutEvent(QFocusEvent *e) {
XYZContainer::focusInEvent(e);
if (cs != 0 && ce != 0)
setSelectedLine(QPoint(0,0));
}
void TContainerLine::m_inFocus(bool value) {
setLine(value);
emit inFocus(value);
}
void TContainerLine::setLine(bool value) {
QPalette pal(Qt::white);
bool selected = false;
if (value) {
pal.setColor(QPalette::Background, Qt::blue);
selected = true;
}
ce->setPalette(pal);
cs->setPalette(pal);
ce->setVisible(selected);
cs->setVisible(selected);
}
void TContainerLine::setSelectedLine(QPoint point) {
QList<TContainerLine *> contLineList = this->parentWidget()->findChildren<TContainerLine *>();
foreach (TContainerLine *contLine, contLineList) {
bool selected = false;
QPointF intersectPnt;
QLineF line(point.x()-5, point.y()-5, point.x()+5, point.y()+5);
if (contLine->line.intersect(line, &intersectPnt) == QLineF::BoundedIntersection) {
if (!contLine->hasFocus()) {
contLine->setFocus();
}
selected = true;
}
if (contLine->ce->hasFocus() && this->ce->rect().contains(point)) {
selected = true;
}
if (contLine->cs->hasFocus() && this->cs->rect().contains(point)) {
selected = true;
}
contLine->setLine(selected);
}
}
void TContainerLine::lineChanged(QRect, QRect) {
if (cs != 0 && !cs->pos().isNull())
line.setP1( cs->pos()+QPoint(3,3) );
if (ce != 0 && !ce->pos().isNull())
line.setP2( ce->pos()+QPoint(3,3) );
}
void TContainerLine::movePoint(XYZContainer *cont, QRect rect) {
cont->move(rect.x(),rect.y());
lineChanged(QRect(),QRect());
this->parentWidget()->repaint();
}
void TContainerLine::setParent(QWidget *parent) {
RptContainer::setParent(parent);
ce->setParent(parent);
cs->setParent(parent);
}
void TContainerLine::setObjectName(const QString &name) {
const QString old_name = this->objectName();
QObject::setObjectName(name);
QString str = this->styleSheet().replace("lbl",name).replace(old_name,name);
this->setStyleSheet(str);
}
void TContainerLine::loadParamFromXML(QDomElement e) {
RptContainer::loadParamFromXML(e);
//this->setSheetValue(BackgroundColor,e.attribute("backgroundColor","rgba(255,255,255,0)"));
this->setSheetValue(BorderColor,e.attribute("borderColor","rgba(0,0,0,255)"));
this->line.setP1(QPointF(e.attribute("lineStartX","0").toDouble(), e.attribute("lineStartY","0" ).toDouble()));
this->line.setP2(QPointF(e.attribute("lineEndX","0").toDouble(), e.attribute("lineEndY","0" ).toDouble()));
this->m_arrowStart = e.attribute("arrowStart","0").toInt();
this->m_arrowEnd = e.attribute("arrowEnd","0").toInt();
this->cs->move(this->line.toLine().p1()-QPoint(3,3));
this->ce->move(this->line.toLine().p2()-QPoint(3,3));
}
QDomElement TContainerLine::saveParamToXML(QDomDocument *xmlDoc) {
QDomElement elem = RptContainer::saveParamToXML(xmlDoc);
QString borderColor = colorToString(getColorValue(BorderColor));
elem.setAttribute("borderColor",borderColor);
elem.setAttribute("borderStyle",getBorderStyleStr());
elem.setAttribute("lineStartX",this->line.p1().x());
elem.setAttribute("lineStartY",this->line.p1().y());
elem.setAttribute("lineEndX",this->line.p2().x());
elem.setAttribute("lineEndY",this->line.p2().y());
elem.setAttribute("arrowStart",this->m_arrowStart);
elem.setAttribute("arrowEnd",this->m_arrowEnd);
return elem;
}
void TContainerLine::setMenu(QMenu *menu_) {
QIcon icon;
QAction *actContDel = new QAction(tr("Delete"),this);
icon.addPixmap(QPixmap(QString::fromUtf8(":/new/prefix1/images/delete.png")), QIcon::Normal, QIcon::On);
actContDel->setObjectName("actContDel");
actContDel->setIcon(icon);
QObject::connect(actContDel, SIGNAL(triggered()), this, SIGNAL(deleteByUser()));
QObject::connect(actContDel, SIGNAL(triggered()), this, SLOT(deleteLater()));
menu->clear();
menu->insertActions(0,menu_->actions());
menu->addAction(actContDel);
}
TContainerLine *TContainerLine::clone() {
TContainerLine *newContField = new TContainerLine(this->parentWidget(),QPoint(0,0),0);
newContField->setType(this->getType());
newContField->setStyleSheet(this->styleSheet());
newContField->setGeometry(this->geometry());
newContField->setBaseSize(this->baseSize());
newContField->setVisible(true);
newContField->move(-10,-10);
newContField->line.setP1( this->line.p1()+QPointF(5,5));
newContField->line.setP2( this->line.p2()+QPointF(5,5));
newContField->cs->move( this->cs->pos()+QPoint(5,5) );
newContField->ce->move( this->ce->pos()+QPoint(5,5) );
newContField->setArrow(ArrowStart, this->getArrow(ArrowStart));
newContField->setArrow(ArrowEnd, this->getArrow(ArrowEnd));
newContField->setColorValue(BorderColor,this->getColorValue(BorderColor));
newContField->setBorderWidth(this->getBorderWidth());
return newContField;
}
qreal TContainerLine::getLength() {
return line.length();
}
void TContainerLine::drawArrow(QPainter *painter) {
// Draw the arrows
static const double Pi = 3.14159265358979323846264338327950288419717;
static double TwoPi = 2.0 * Pi;
double angle = ::acos(line.dx() / line.length());
if (line.dy() >= 0)
angle = TwoPi - angle;
QPointF sourcePoint = line.p1();
QPointF destPoint = line.p2();
int arrowSize= 10;
painter->setBrush(getColorValue(BorderColor));
if (m_arrowStart) {
QPointF sourceArrowP1 = sourcePoint + QPointF(sin(angle + Pi / 3) * arrowSize,
cos(angle + Pi / 3) * arrowSize);
QPointF sourceArrowP2 = sourcePoint + QPointF(sin(angle + Pi - Pi / 3) * arrowSize,
cos(angle + Pi - Pi / 3) * arrowSize);
painter->drawPolygon(QPolygonF() << line.p1() << sourceArrowP1 << sourceArrowP2);
}
if (m_arrowEnd) {
QPointF destArrowP1 = destPoint + QPointF(sin(angle - Pi / 3) * arrowSize,
cos(angle - Pi / 3) * arrowSize);
QPointF destArrowP2 = destPoint + QPointF(sin(angle - Pi + Pi / 3) * arrowSize,
cos(angle - Pi + Pi / 3) * arrowSize);
painter->drawPolygon(QPolygonF() << line.p2() << destArrowP1 << destArrowP2);
}
}
TContainerLine::~TContainerLine() {
if (cs != 0) {
cs->deleteLater();
cs = 0;
}
if (ce != 0) {
ce->deleteLater();
ce = 0;
}
}
void TContainerLine::setProperties() {
this->setProperty("FieldType",m_type);
}
//Restore fields from properties
void TContainerLine::setParamFromProperties() {
m_type = (FieldType)this->property("FieldType").toInt();
}
QDataStream &operator<<(QDataStream &stream, const TContainerLine &obj) {
for(int i=0; i<obj.metaObject()->propertyCount(); ++i) {
if(obj.metaObject()->property(i).isStored(&obj)) {
stream << obj.metaObject()->property(i).read(&obj);
}
}
QList<QByteArray> list = obj.dynamicPropertyNames();
for (int i=0; i<list.size(); i++) {
stream << obj.property(list.at(i));
}
stream << *obj.cs;
stream << *obj.ce;
return stream;
}
QDataStream &operator>>(QDataStream &stream, TContainerLine &obj) {
QVariant var;
for(int i=0; i<obj.metaObject()->propertyCount(); ++i) {
if(obj.metaObject()->property(i).isStored(&obj)) {
stream >> var;
if (!var.isNull())
obj.metaObject()->property(i).write(&obj, var);
}
}
obj.setProperties();
QList<QByteArray> list = obj.dynamicPropertyNames();
for (int i=0; i<list.size(); i++) {
stream >> var;
obj.setProperty(list.at(i),QVariant(var));
}
obj.setParamFromProperties();
stream >> *obj.cs;
stream >> *obj.ce;
return stream;
}
| 35.150685 | 115 | 0.633983 | salim97 |
3717cf8ec69118ea296ade4607ef88216db07397 | 7,573 | cpp | C++ | td/telegram/net/SessionProxy.cpp | sintyaaaaa/td | 0e930c15d3cd65dc5cc3fa6e8492684038129510 | [
"BSL-1.0"
] | 1 | 2019-10-12T18:08:04.000Z | 2019-10-12T18:08:04.000Z | td/telegram/net/SessionProxy.cpp | sintyaaaaa/td | 0e930c15d3cd65dc5cc3fa6e8492684038129510 | [
"BSL-1.0"
] | null | null | null | td/telegram/net/SessionProxy.cpp | sintyaaaaa/td | 0e930c15d3cd65dc5cc3fa6e8492684038129510 | [
"BSL-1.0"
] | 1 | 2020-08-14T12:43:30.000Z | 2020-08-14T12:43:30.000Z | //
// Copyright Aliaksei Levin ([email protected]), Arseny Smirnov ([email protected]) 2014-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)
//
#include "td/telegram/net/SessionProxy.h"
#include "td/telegram/Global.h"
#include "td/telegram/net/ConnectionCreator.h"
#include "td/telegram/net/DcId.h"
#include "td/telegram/net/NetQueryDispatcher.h"
#include "td/telegram/net/Session.h"
#include "td/telegram/UniqueId.h"
#include "td/actor/PromiseFuture.h"
#include "td/utils/common.h"
#include "td/utils/logging.h"
#include "td/utils/Slice.h"
#include <functional>
namespace td {
namespace mtproto {
class RawConnection;
} // namespace mtproto
class SessionCallback : public Session::Callback {
public:
SessionCallback(ActorShared<SessionProxy> parent, DcId dc_id, bool allow_media_only, bool is_media, size_t hash)
: parent_(std::move(parent))
, dc_id_(dc_id)
, allow_media_only_(allow_media_only)
, is_media_(is_media)
, hash_(hash) {
}
void on_failed() override {
send_closure(parent_, &SessionProxy::on_failed);
}
void on_closed() override {
send_closure(parent_, &SessionProxy::on_closed);
}
void request_raw_connection(unique_ptr<mtproto::AuthData> auth_data,
Promise<unique_ptr<mtproto::RawConnection>> promise) override {
send_closure(G()->connection_creator(), &ConnectionCreator::request_raw_connection, dc_id_, allow_media_only_,
is_media_, std::move(promise), hash_, std::move(auth_data));
}
void on_tmp_auth_key_updated(mtproto::AuthKey auth_key) override {
send_closure(parent_, &SessionProxy::on_tmp_auth_key_updated, std::move(auth_key));
}
void on_server_salt_updated(std::vector<mtproto::ServerSalt> server_salts) override {
send_closure(parent_, &SessionProxy::on_server_salt_updated, std::move(server_salts));
}
void on_result(NetQueryPtr query) override {
if (UniqueId::extract_type(query->id()) != UniqueId::BindKey &&
query->id() != 0) { // not bind key query and not an update
send_closure(parent_, &SessionProxy::on_query_finished);
}
G()->net_query_dispatcher().dispatch(std::move(query));
}
private:
ActorShared<SessionProxy> parent_;
DcId dc_id_;
bool allow_media_only_ = false;
bool is_media_ = false;
size_t hash_ = 0;
};
SessionProxy::SessionProxy(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data,
bool is_main, bool allow_media_only, bool is_media, bool use_pfs, bool is_cdn,
bool need_destroy)
: callback_(std::move(callback))
, auth_data_(std::move(shared_auth_data))
, is_main_(is_main)
, allow_media_only_(allow_media_only)
, is_media_(is_media)
, use_pfs_(use_pfs)
, is_cdn_(is_cdn)
, need_destroy_(need_destroy) {
}
void SessionProxy::start_up() {
class Listener : public AuthDataShared::Listener {
public:
explicit Listener(ActorShared<SessionProxy> session_proxy) : session_proxy_(std::move(session_proxy)) {
}
bool notify() override {
if (!session_proxy_.is_alive()) {
return false;
}
send_closure(session_proxy_, &SessionProxy::update_auth_key_state);
return true;
}
private:
ActorShared<SessionProxy> session_proxy_;
};
auth_key_state_ = auth_data_->get_auth_key_state().first;
auth_data_->add_auth_key_listener(make_unique<Listener>(actor_shared(this)));
open_session();
}
void SessionProxy::tear_down() {
for (auto &query : pending_queries_) {
query->resend();
callback_->on_query_finished();
G()->net_query_dispatcher().dispatch(std::move(query));
}
pending_queries_.clear();
}
void SessionProxy::send(NetQueryPtr query) {
if (query->auth_flag() == NetQuery::AuthFlag::On && auth_key_state_ != AuthKeyState::OK) {
query->debug(PSTRING() << get_name() << ": wait for auth");
pending_queries_.emplace_back(std::move(query));
return;
}
open_session(true);
query->debug(PSTRING() << get_name() << ": sent to session");
send_closure(session_, &Session::send, std::move(query));
}
void SessionProxy::update_main_flag(bool is_main) {
if (is_main_ == is_main) {
return;
}
LOG(INFO) << "Update " << get_name() << " is_main to " << is_main;
is_main_ = is_main;
close_session();
open_session();
}
void SessionProxy::update_destroy(bool need_destroy) {
need_destroy_ = need_destroy;
close_session();
open_session();
}
void SessionProxy::on_failed() {
if (session_generation_ != get_link_token()) {
return;
}
close_session();
open_session();
}
void SessionProxy::update_mtproto_header() {
close_session();
open_session();
}
void SessionProxy::on_closed() {
}
void SessionProxy::close_session() {
send_closure(std::move(session_), &Session::close);
session_generation_++;
}
void SessionProxy::open_session(bool force) {
if (!session_.empty()) {
return;
}
// There are several assumption that make this code OK
// 1. All unauthorized query will be sent into the same SessionProxy
// 2. All authorized query are delayed before we have authorization
// So only one SessionProxy will be active before we have authorization key
auto should_open = [&]() {
if (force) {
return true;
}
if (need_destroy_) {
return auth_key_state_ != AuthKeyState::Empty;
}
if (auth_key_state_ != AuthKeyState::OK) {
return false;
}
return is_main_ || !pending_queries_.empty();
}();
if (!should_open) {
return;
}
CHECK(session_.empty());
auto dc_id = auth_data_->dc_id();
string name = PSTRING() << "Session" << get_name().substr(Slice("SessionProxy").size());
string hash_string = PSTRING() << name << " " << dc_id.get_raw_id() << " " << allow_media_only_;
auto hash = std::hash<std::string>()(hash_string);
int32 int_dc_id = dc_id.get_raw_id();
if (G()->is_test_dc()) {
int_dc_id += 10000;
}
if (allow_media_only_ && !is_cdn_) {
int_dc_id = -int_dc_id;
}
session_ = create_actor<Session>(
name,
make_unique<SessionCallback>(actor_shared(this, session_generation_), dc_id, allow_media_only_, is_media_, hash),
auth_data_, int_dc_id, is_main_, use_pfs_, is_cdn_, need_destroy_, tmp_auth_key_, server_salts_);
}
void SessionProxy::update_auth_key_state() {
auto old_auth_key_state = auth_key_state_;
auth_key_state_ = auth_data_->get_auth_key_state().first;
if (auth_key_state_ != old_auth_key_state && old_auth_key_state == AuthKeyState::OK) {
close_session();
}
open_session();
if (session_.empty() || auth_key_state_ != AuthKeyState::OK) {
return;
}
for (auto &query : pending_queries_) {
query->debug(PSTRING() << get_name() << ": sent to session");
send_closure(session_, &Session::send, std::move(query));
}
pending_queries_.clear();
}
void SessionProxy::on_tmp_auth_key_updated(mtproto::AuthKey auth_key) {
Slice state;
if (auth_key.empty()) {
state = Slice("Empty");
} else if (auth_key.auth_flag()) {
state = Slice("OK");
} else {
state = Slice("NoAuth");
}
LOG(WARNING) << "Have tmp_auth_key " << auth_key.id() << ": " << state;
tmp_auth_key_ = std::move(auth_key);
}
void SessionProxy::on_server_salt_updated(std::vector<mtproto::ServerSalt> server_salts) {
server_salts_ = std::move(server_salts);
}
void SessionProxy::on_query_finished() {
callback_->on_query_finished();
}
} // namespace td
| 30.784553 | 119 | 0.692196 | sintyaaaaa |
371b9f40f7dbb7f926000ae17bcff9791eed1aad | 4,753 | cpp | C++ | src/gamecredits.cpp | cpusam/dangerous_tux | e5f099f3e3665d62f1c484458125f003c1d5eece | [
"Zlib"
] | 1 | 2020-09-18T07:43:07.000Z | 2020-09-18T07:43:07.000Z | src/gamecredits.cpp | cpusam/dangerous_tux | e5f099f3e3665d62f1c484458125f003c1d5eece | [
"Zlib"
] | null | null | null | src/gamecredits.cpp | cpusam/dangerous_tux | e5f099f3e3665d62f1c484458125f003c1d5eece | [
"Zlib"
] | null | null | null | #include "gamecredits.hpp"
CGameCredits::CGameCredits ( SDL_Renderer * r )
{
SDL_Surface * aux;
#if _WIN32 || _WIN64
char path[FILENAME_MAX], bg_path[FILENAME_MAX];
char p2[FILENAME_MAX];
_getcwd(p2, sizeof(p2));
#else
char path[1024], bg_path[1024];
#endif
#if _WIN32 || _WIN64
#ifndef PREFIX
sprintf(path, "%s\\fonts\\inhouseedition.ttf", p2);
#else
sprintf(path, "%s\\dangeroustux\\fonts\\inhouseedition.ttf", PREFIX);
#endif
#else
#ifndef PREFIX
sprintf(path, "./fonts/inhouseedition.ttf");
#else
sprintf(path, "%s/share/games/dangeroustux/fonts/inhouseedition.ttf", PREFIX);
#endif
#endif
if (!Writer::instance()->load_font(path, path, 100))
throw "CGameCredits: não foi possível carregar font\n";
Writer::instance()->set_renderer(r);
char s[5][32] =
{
{71,82,65,80,72,73,67,83},
{71,85,83,84,65,86,79,32,77,69,68,69,73,82,79,83},
{80,82,79,71,82,65,77,77,73,78,71},
{83,65,77,85,69,76,32,76,69,79,78,65,82,68,79},
{84,72,73,65,71,79,32,72,85,80,78,69,82},
};
GuiLabel * g = new GuiLabel(s[0], (SDL_Color){255,255,255,0});
widget.add_child(g);
GuiLabel * gg = new GuiLabel(s[1], (SDL_Color){255,255,0,0});
widget.add_child(gg);
GuiLabel * p = new GuiLabel(s[2], (SDL_Color){255,255,255,0});
widget.add_child(p);
GuiLabel * ps = new GuiLabel(s[3], (SDL_Color){255,255,0,0});
widget.add_child(ps);
GuiLabel * t = new GuiLabel(s[4], (SDL_Color){255,255,0,0});
widget.add_child(t);
widget.set_pos(Vect(960/2,624/2));
int h = g->get_texture_height() + gg->get_texture_height() + p->get_texture_height() + ps->get_texture_height();
g->set_rel_pos(Vect(-(g->get_texture_width()/2), h));
gg->set_rel_pos(Vect(-(gg->get_texture_width()/2), g->get_texture_height() + g->get_rel_pos().y));
p->set_rel_pos(Vect(-(p->get_texture_width()/2), gg->get_texture_height() + gg->get_rel_pos().y));
ps->set_rel_pos(Vect(-(ps->get_texture_width()/2), p->get_texture_height() + p->get_rel_pos().y));
t->set_rel_pos(Vect(-(t->get_texture_width()/2), ps->get_texture_height() + ps->get_rel_pos().y));
#if _WIN32 || _WIN64
#ifndef PREFIX
sprintf(path, "%s\\images\\tux_walk.png", p2);
#else
sprintf(path, "%s\\dangeroustux\\images\\tux_walk.png", PREFIX);
#endif
#else
#ifndef PREFIX
sprintf(path, "./images/tux_walk.png");
#else
sprintf(path, "%s/share/games/dangeroustux/images/tux_walk.png", PREFIX);
#endif
#endif
#if _WIN32 || _WIN64
#ifndef PREFIX
sprintf(bg_path, "%s\\images\\credits_BG.png", p2);
#else
sprintf(bg_path, "%s\\dangeroustux\\images\\credits_BG.png", PREFIX);
#endif
#else
#ifndef PREFIX
sprintf(bg_path, "./images/credits_BG.png");
#else
sprintf(bg_path, "%s/share/games/dangeroustux/images/credits_BG.png", PREFIX);
#endif
#endif
anim.add_frame(NULL, (SDL_Rect){0,0,0,0}, 15000);
SDL_Texture * texture = IMG_LoadTexture(r, path);
if (!texture)
throw "CGameCredits: não foi possivel carregar tux_walk.png\n";
tux_anim.add_frame(texture, (SDL_Rect){0, 0,214,234}, 200);
tux_anim.add_frame(texture, (SDL_Rect){0, 234,214,234}, 200); // meio
tux_anim.add_frame(texture, (SDL_Rect){0,2*234,214,234}, 200);
tux_anim.add_frame(texture, (SDL_Rect){0, 234,214,234}, 200); // meio
//tux_pos.x = widget.get_pos().x - texture_width(texture)/2;
tux_pos.x = (960 - texture_width(texture))/2;
if (!bg.set_texture(IMG_LoadTexture(r, bg_path)))
throw "CGameCredits: não foi possível carregar credits_BG.png\n";
//widget.set_pos(Vect(960/2, 358/2));
tux_pos.y = 358;
cam = new Camera((SDL_Rect){0,0,texture_width(bg.get_texture()),texture_height(bg.get_texture())}, (SDL_Rect){0,0,2000*texture_width(bg.get_texture()),texture_height(bg.get_texture())});
set_state(ACTIVE_CREDITS);
}
CGameCredits::~CGameCredits ( )
{
Widget * w = widget.get_child(0);
for (int i = 0; w; i++, w = widget.get_child(i))
delete w;
delete cam;
tux_anim.destroy_textures();
}
void CGameCredits::draw ( SDL_Renderer * renderer )
{
SDL_SetRenderDrawColor(renderer, 0x00,0xc6,0xff,0xFF);
SDL_RenderFillRect(renderer, NULL);
bg.draw_hor(renderer, cam);
tux_anim.draw(renderer, tux_pos.x, tux_pos.y);
widget.draw(renderer);
}
void CGameCredits::reset ( )
{
bg_pos.zero();
cam->set_position(Vect());
anim.reset();
tux_anim.reset();
set_state(ACTIVE_CREDITS);
}
int CGameCredits::update ( )
{
bg_pos.x += 5.50f;
cam->set_position(bg_pos);
auto children = widget.get_children();
for (auto child : children){
auto pos = child->get_pos();
if (pos.y < -1000) break;
pos.y -= 2.5f;
child->set_pos(pos);
}
widget.child_update();
widget.update();
tux_anim.update();
if (anim.update() == 3)
set_state(INACTIVE_CREDITS);
return get_state();
}
| 27.795322 | 187 | 0.673469 | cpusam |
7deab687b399e21866c78bbc3df6a2a9c3b22180 | 2,600 | cpp | C++ | src/TestPorter/main.cpp | v1otusc/wondertrader | fd65a052d26be32882f89e8e9dfcd1d7b8736a3b | [
"MIT"
] | null | null | null | src/TestPorter/main.cpp | v1otusc/wondertrader | fd65a052d26be32882f89e8e9dfcd1d7b8736a3b | [
"MIT"
] | 1 | 2022-03-21T06:51:59.000Z | 2022-03-21T06:51:59.000Z | src/TestPorter/main.cpp | v1otusc/wondertrader | fd65a052d26be32882f89e8e9dfcd1d7b8736a3b | [
"MIT"
] | null | null | null | #define _CRT_SECURE_NO_WARNINGS
#include "../WtPorter/WtPorter.h"
//#include "../WtExecMon/WtExecPorter.h"
#include "../Includes/WTSStruct.h"
#include "../Share/DLLHelper.hpp"
#include "../Share/CodeHelper.hpp"
void PORTER_FLAG on_init(CtxHandler ctxid)
{
printf("on_init\r\n");
hft_sub_ticks(ctxid, "CFFEX.IF.HOT");
}
void PORTER_FLAG on_tick(CtxHandler ctxid, const char* stdCode, WTSTickStruct* newTick)
{
printf("on_tick\r\n");
}
void PORTER_FLAG on_calc(CtxHandler ctxid, WtUInt32 uDate, WtUInt32 uTime)
{
printf("on_calc\r\n");
}
void PORTER_FLAG on_bar(CtxHandler ctxid, const char* code, const char* period, WTSBarStruct* newBar)
{
printf("on_bar\r\n");
}
void PORTER_FLAG on_getbar(CtxHandler ctxid, const char* code, const char* period, WTSBarStruct* bar, bool isLast)
{
if (bar)
printf("on_getbar%I64d\r\n", bar->time);
else
int x = 1;
}
void PORTER_FLAG on_getticks(CtxHandler cHandle, const char* code, WTSTickStruct* tick, bool isLast)
{
printf("on_getticks\r\n");
}
void PORTER_FLAG on_event(WtUInt32 evtId, WtUInt32 curDate, WtUInt32 curTime)
{
printf("on_event\r\n");
}
void PORTER_FLAG on_channel_evt(CtxHandler cHandle, const char* trader, WtUInt32 evtid)
{
printf("on_channel_evt\r\n");
double undone = hft_get_undone(cHandle, "CFFEX.IF.HOT");
}
void PORTER_FLAG on_order(CtxHandler cHandle, WtUInt32 localid, const char* stdCode, bool isBuy, double totalQty, double leftQty, double price, bool isCanceled, const char* userTag)
{
}
void PORTER_FLAG on_trade(CtxHandler cHandle, WtUInt32 localid, const char* stdCode, bool isBuy, double vol, double price, const char* userTag)
{
}
void PORTER_FLAG on_entrust(CtxHandler cHandle, WtUInt32 localid, const char* stdCode, bool bSuccess, const char* message, const char* userTag)
{
}
void PORTER_FLAG on_order_queue(CtxHandler cHandle, const char* stdCode, WTSOrdQueStruct* ordQue)
{
}
void PORTER_FLAG on_order_detail(CtxHandler cHandle, const char* stdCode, WTSOrdDtlStruct* ordDtl)
{
}
void PORTER_FLAG on_transaction(CtxHandler cHandle, const char* stdCode, WTSTransStruct* trans)
{
}
void test_porter()
{
#ifdef _WIN32
DLLHelper::load_library("WtPorter.dll");
#else
DLLHelper::load_library("libWtPorter.so");
#endif
init_porter("logcfg.json", true, "./generated");
reg_hft_factories("./hft");
config_porter("config.json", true);
run_porter(true);
printf("press enter key to exit\n");
getchar();
release_porter();
}
int main()
{
test_porter();
getchar();
return 0;
}
| 23.423423 | 182 | 0.715 | v1otusc |
7ded15a6131f165f97675f07465255b4d67d5048 | 2,007 | hpp | C++ | modules/core/combinatorial/include/nt2/combinatorial/functions/lcm.hpp | feelpp/nt2 | 4d121e2c7450f24b735d6cff03720f07b4b2146c | [
"BSL-1.0"
] | 34 | 2017-05-19T18:10:17.000Z | 2022-01-04T02:18:13.000Z | modules/core/combinatorial/include/nt2/combinatorial/functions/lcm.hpp | feelpp/nt2 | 4d121e2c7450f24b735d6cff03720f07b4b2146c | [
"BSL-1.0"
] | null | null | null | modules/core/combinatorial/include/nt2/combinatorial/functions/lcm.hpp | feelpp/nt2 | 4d121e2c7450f24b735d6cff03720f07b4b2146c | [
"BSL-1.0"
] | 7 | 2017-12-02T12:59:17.000Z | 2021-07-31T12:46:14.000Z | //==============================================================================
// Copyright 2003 - 2012 LASMEA UMR 6602 CNRS/Univ. Clermont II
// Copyright 2009 - 2012 LRI UMR 8623 CNRS/Univ Paris Sud XI
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef NT2_COMBINATORIAL_FUNCTIONS_LCM_HPP_INCLUDED
#define NT2_COMBINATORIAL_FUNCTIONS_LCM_HPP_INCLUDED
#include <nt2/include/functor.hpp>
namespace nt2 { namespace tag
{
/*!
@brief lcm generic tag
Represents the lcm function in generic contexts.
@par Models:
Hierarchy
**/
struct lcm_ : ext::elementwise_<lcm_>
{
/// @brief Parent hierarchy
typedef ext::elementwise_<lcm_> parent;
template<class... Args>
static BOOST_FORCEINLINE BOOST_AUTO_DECLTYPE dispatch(Args&&... args)
BOOST_AUTO_DECLTYPE_BODY( dispatching_lcm_( ext::adl_helper(), static_cast<Args&&>(args)... ) )
};
}
namespace ext
{
template<class Site>
BOOST_FORCEINLINE generic_dispatcher<tag::lcm_, Site> dispatching_lcm_(adl_helper, boost::dispatch::meta::unknown_<Site>, ...)
{
return generic_dispatcher<tag::lcm_, Site>();
}
template<class... Args>
struct impl_lcm_;
}
/*!
Computes the least common multiple
If parameters are floating point and not flint,
nan is returned.
@par Semantic:
For every table expressions
@code
auto r = lcm(a0,a1);
@endcode
- If any input is zero 0 is returned
- If parameters are floating point and not flint,
nan is returned.
@see @funcref{gcd}, @funcref{is_flint}
@param a0
@param a1
@return an expression which eventually will evaluate to the result
**/
NT2_FUNCTION_IMPLEMENTATION(tag::lcm_, lcm, 2)
}
#endif
| 27.875 | 129 | 0.607872 | feelpp |
7dedaf628f5693f3e7aed18de73c8d00ddeedc27 | 3,190 | cpp | C++ | src/vulkan/vulkan_render.cpp | cmaughan/vklive | 649c64335d7d77f4d3199ea8f66c04a53455b4a9 | [
"MIT"
] | null | null | null | src/vulkan/vulkan_render.cpp | cmaughan/vklive | 649c64335d7d77f4d3199ea8f66c04a53455b4a9 | [
"MIT"
] | null | null | null | src/vulkan/vulkan_render.cpp | cmaughan/vklive | 649c64335d7d77f4d3199ea8f66c04a53455b4a9 | [
"MIT"
] | null | null | null | #include "vklive/vulkan/vulkan_render.h"
#include "config_app.h"
#include "vklive/file/file.h"
#include "vklive/vulkan/vulkan_framebuffer.h"
#include "vklive/vulkan/vulkan_model.h"
#include "vklive/vulkan/vulkan_pipeline.h"
#include "vklive/vulkan/vulkan_shader.h"
#include "vklive/vulkan/vulkan_uniform.h"
#include "vklive/vulkan/vulkan_utils.h"
#include "vklive/vulkan/vulkan_scene.h"
namespace vulkan
{
namespace
{
// Vertex layout for this example
VertexLayout g_vertexLayout{ {
Component::VERTEX_COMPONENT_POSITION,
Component::VERTEX_COMPONENT_UV,
Component::VERTEX_COMPONENT_COLOR,
Component::VERTEX_COMPONENT_NORMAL,
} };
} // namespace
std::shared_ptr<RenderContext> render_context(VulkanContext& ctx)
{
return std::static_pointer_cast<RenderContext>(ctx.spRenderData);
}
void render_init(VulkanContext& ctx)
{
auto spRender = std::make_shared<RenderContext>();
ctx.spRenderData = spRender;
}
void render_destroy_images(VulkanContext& ctx, RenderContext& renderContext)
{
for (auto& buffer : renderContext.colorBuffers)
{
image_destroy(ctx, buffer);
}
renderContext.colorBuffers.clear();
if (renderContext.depthBuffer.format != vk::Format::eUndefined)
{
image_destroy(ctx, renderContext.depthBuffer);
}
}
void render_destroy(VulkanContext& ctx)
{
auto spRender = render_context(ctx);
render_destroy_images(ctx, *spRender);
ctx.spRenderData = nullptr;
}
void render_create_images(VulkanContext& ctx, RenderContext& renderContext, const glm::uvec2& size, vk::Format colorFormat, vk::Format depthFormat)
{
render_destroy_images(ctx, renderContext);
renderContext.colorBuffers.resize(1);
image_create(ctx, renderContext.colorBuffers[0], size, colorFormat, true, "RenderDefault");
bool useDepth = depthFormat != vk::Format::eUndefined;
if (useDepth)
{
image_create_depth(ctx, renderContext.depthBuffer, size, depthFormat, false, "RenderDefault");
}
}
void render_check_framebuffer(VulkanContext& ctx, const glm::uvec2& size)
{
auto spRender = render_context(ctx);
if (spRender->frameBufferSize == size)
{
return;
}
// Might still be rendering to/with this FB, so wait for it.
ctx.device.waitIdle();
// Destroy old
spRender->frameBufferSize = size;
render_create_images(ctx, *spRender, glm::uvec2(size), vk::Format::eR8G8B8A8Unorm, vk::Format::eD32Sfloat);
image_set_sampling(ctx, spRender->colorBuffers[0]);
debug_set_descriptorsetlayout_name(ctx.device, spRender->colorBuffers[0].samplerDescriptorSetLayout, "RenderColorBuffer::DescriptorSetLayout");
debug_set_descriptorset_name(ctx.device, spRender->colorBuffers[0].samplerDescriptorSet, "RenderColorBuffer::DescriptorSet");
debug_set_sampler_name(ctx.device, spRender->colorBuffers[0].sampler, "RenderColorBuffer::Sampler");
}
void render(VulkanContext& ctx, const glm::vec4& rect, Scene& scene)
{
auto spRender = render_context(ctx);
// Check the framebuffer
render_check_framebuffer(ctx, glm::uvec2(rect.z, rect.w));
// Render the scene
vulkan::vulkan_scene_render(ctx, *spRender, scene);
}
} // namespace vulkan
| 30.380952 | 147 | 0.739812 | cmaughan |
7df0b3aafe209df5e363f70d0ee3c4300b71f6c0 | 2,835 | cc | C++ | tests/unit/stall_detector_test.cc | jwnx/seastar | 4207837dfbc969e46c0b581e6c3f801dbc8f3a07 | [
"Apache-2.0"
] | null | null | null | tests/unit/stall_detector_test.cc | jwnx/seastar | 4207837dfbc969e46c0b581e6c3f801dbc8f3a07 | [
"Apache-2.0"
] | null | null | null | tests/unit/stall_detector_test.cc | jwnx/seastar | 4207837dfbc969e46c0b581e6c3f801dbc8f3a07 | [
"Apache-2.0"
] | 1 | 2020-08-10T12:54:33.000Z | 2020-08-10T12:54:33.000Z | /*
* This file is open source software, licensed to you under the terms
* of the Apache License, Version 2.0 (the "License"). See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership. 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.
*/
/*
* Copyright (C) 2018 ScyllaDB Ltd.
*/
#include <seastar/core/reactor.hh>
#include <seastar/testing/test_case.hh>
#include <seastar/testing/thread_test_case.hh>
#include <atomic>
#include <chrono>
using namespace seastar;
using namespace std::chrono_literals;
class temporary_stall_detector_settings {
std::chrono::milliseconds _old_threshold;
std::function<void ()> _old_report;
public:
temporary_stall_detector_settings(std::chrono::duration<double> threshold, std::function<void ()> report)
: _old_threshold(engine().get_blocked_reactor_notify_ms())
, _old_report(engine().get_stall_detector_report_function()) {
engine().update_blocked_reactor_notify_ms(std::chrono::duration_cast<std::chrono::milliseconds>(threshold));
engine().set_stall_detector_report_function(std::move(report));
}
~temporary_stall_detector_settings() {
engine().update_blocked_reactor_notify_ms(_old_threshold);
engine().set_stall_detector_report_function(std::move(_old_report));
}
};
void spin(std::chrono::duration<double> how_much) {
auto end = std::chrono::steady_clock::now() + how_much;
while (std::chrono::steady_clock::now() < end) {
// spin!
}
}
void spin_some_cooperatively(std::chrono::duration<double> how_much) {
auto end = std::chrono::steady_clock::now() + how_much;
while (std::chrono::steady_clock::now() < end) {
spin(200us);
if (need_preempt()) {
thread::yield();
}
}
}
SEASTAR_THREAD_TEST_CASE(normal_case) {
std::atomic<unsigned> reports{};
temporary_stall_detector_settings tsds(10ms, [&] { ++reports; });
spin_some_cooperatively(1s);
BOOST_REQUIRE_EQUAL(reports, 0);
}
SEASTAR_THREAD_TEST_CASE(simple_stalls) {
std::atomic<unsigned> reports{};
temporary_stall_detector_settings tsds(10ms, [&] { ++reports; });
unsigned nr = 10;
for (unsigned i = 0; i < nr; ++i) {
spin_some_cooperatively(100ms);
spin(20ms);
}
spin_some_cooperatively(100ms);
BOOST_REQUIRE_EQUAL(reports, 10);
}
| 33.75 | 116 | 0.703351 | jwnx |
7df2058ba1ee34629e396e88716ad9a0bf07a1a5 | 3,979 | hpp | C++ | include/bitpacker/bitpacker.hpp | YarikTH/bitpacker | a778a5ab5eab2cee80beb1819ee7d352775db046 | [
"BSL-1.0"
] | null | null | null | include/bitpacker/bitpacker.hpp | YarikTH/bitpacker | a778a5ab5eab2cee80beb1819ee7d352775db046 | [
"BSL-1.0"
] | null | null | null | include/bitpacker/bitpacker.hpp | YarikTH/bitpacker | a778a5ab5eab2cee80beb1819ee7d352775db046 | [
"BSL-1.0"
] | null | null | null | #pragma once
#include <array>
#include <bitset>
#include <cassert>
#if !defined( BITPACKER_USE_STD_BIT )
# define BITPACKER_USE_STD_BIT __has_include( <bit> ) && __cplusplus >= 202002L
#endif
#if BITPACKER_USE_STD_BIT
# include <bit>
#endif
#define BITPACKER_VERSION_MAJOR 0
#define BITPACKER_VERSION_MINOR 1
#define BITPACKER_VERSION_PATCH 0
#define BITPACKER_VERSION_STR "0.1.0"
#define BITPACKER_VERSION \
( BITPACKER_VERSION_MAJOR * 10000 + BITPACKER_VERSION_MINOR * 100 + BITPACKER_VERSION_PATCH )
namespace bitpacker
{
#if BITPACKER_USE_STD_BIT
using std::bit_width;
#else
template <class V, std::enable_if_t<std::is_unsigned_v<V>, int> = 0>
[[nodiscard]] constexpr V bit_width( const V value ) noexcept
{
V result = 0u;
V temp = value;
while( temp != 0u )
{
++result;
temp >>= static_cast<V>( 1u );
}
return result;
}
#endif
template <class ContainerT>
class bit_ostream
{
public:
constexpr explicit bit_ostream( ContainerT& data )
: m_data( data )
{}
constexpr bit_ostream& operator<<( const bool value )
{
assert( m_offset < m_data.size() );
m_data[m_offset++] = value;
return *this;
}
[[nodiscard]] constexpr size_t offset() const
{
return m_offset;
}
private:
ContainerT& m_data;
size_t m_offset = 0;
};
template <class ContainerT>
class bit_istream
{
public:
constexpr explicit bit_istream( ContainerT& data )
: m_data( data )
{}
constexpr bit_istream& operator>>( bool& value )
{
assert( m_offset < m_data.size() );
value = m_data[m_offset++];
return *this;
}
[[nodiscard]] constexpr size_t offset() const
{
return m_offset;
}
private:
ContainerT& m_data;
size_t m_offset = 0;
};
/// Return unsigned difference between two integers
/// Left hand side value should be greater or equal than right hand side value
template <typename V, class UnsignedV = typename std::make_unsigned<V>::type>
[[nodiscard]] constexpr UnsignedV integral_unsigned_difference( const V lhs, const V rhs )
{
return static_cast<UnsignedV>( lhs ) - static_cast<UnsignedV>( rhs );
}
/// Calculate delta for integral values with given range
template <typename V, class UnsignedV = typename std::make_unsigned<V>::type>
[[nodiscard]] constexpr UnsignedV integral_delta( const V min_value, const V max_value )
{
return integral_unsigned_difference( max_value, min_value );
}
/// Calculate delta for integral values without limits
template <typename V, class UnsignedV = typename std::make_unsigned<V>::type>
[[nodiscard]] constexpr UnsignedV integral_delta()
{
const auto min_value = std::numeric_limits<V>::min();
const auto max_value = std::numeric_limits<V>::max();
return integral_delta( min_value, max_value );
}
// Pack normalized value in range from 0 to delta
template <typename V, typename OutputBitStreamT>
constexpr void pack_normalized_value( OutputBitStreamT& obstream, const V value, const V delta )
{
static_assert( std::is_unsigned_v<V> );
auto temp = value;
constexpr auto ONE = static_cast<V>( 1 );
for( size_t i = 0, ie = bit_width( delta ); i < ie; ++i )
{
const bool bit = temp & ONE;
obstream << bit;
temp >>= ONE;
}
}
template <typename V, typename InputBitStreamT>
constexpr V unpack_normalized_value( InputBitStreamT& ibstream, const V delta )
{
V value{};
constexpr auto ONE = static_cast<V>( 1 );
for( size_t i = 0, ie = bit_width( delta ); i < ie; ++i )
{
bool bit{};
ibstream >> bit;
if( bit )
{
value |= ( ONE << i );
}
}
return value;
}
} // namespace bitpacker
| 25.837662 | 101 | 0.627042 | YarikTH |
7df26e063b76c4063de18842b4922826bd4706a0 | 14,125 | cpp | C++ | src/mme-app/utils/mmeCommonUtils.cpp | dksan23/Nucleus | 0377bee9cacebe352caba9d9cf76dcc9af9e69bf | [
"Apache-2.0"
] | null | null | null | src/mme-app/utils/mmeCommonUtils.cpp | dksan23/Nucleus | 0377bee9cacebe352caba9d9cf76dcc9af9e69bf | [
"Apache-2.0"
] | 1 | 2021-05-12T09:17:31.000Z | 2021-05-12T09:17:31.000Z | src/mme-app/utils/mmeCommonUtils.cpp | dksan23/Nucleus | 0377bee9cacebe352caba9d9cf76dcc9af9e69bf | [
"Apache-2.0"
] | 6 | 2021-05-06T11:18:55.000Z | 2021-05-12T13:13:21.000Z | /*
* Copyright (c) 2019, Infosys Ltd.
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <utils/mmeCommonUtils.h>
#include <cmath>
#include <controlBlock.h>
#include <contextManager/dataBlocks.h>
#include <contextManager/subsDataGroupManager.h>
#include <log.h>
#include <mme_app.h>
#include <msgBuffer.h>
#include <s1ap_structs.h>
#include <utils/defaultMmeProcedureCtxt.h>
#include <random>
using namespace mme;
extern mme_config_t *mme_cfg;
bool MmeCommonUtils::isLocalGuti(const guti &guti_r)
{
bool rc = false;
if (guti_r.mme_grp_id == mme_cfg->mme_group_id &&
guti_r.mme_code == mme_cfg->mme_code)
{
rc = true;
}
return rc;
}
#ifdef S10_FEATURE
bool MmeCommonUtils::compare_plmn_id(const struct PLMN *plmn)
{
bool rc = false;
//need to check whether this comparison will work or not, else need to decode idx to mcc and mnc
int config_plmn;
for(config_plmn = 0; config_plmn < mme_cfg->num_plmns; config_plmn++)
{
if((mme_cfg->plmns[config_plmn].idx[0] == plmn->idx[0]) &&
(mme_cfg->plmns[config_plmn].idx[1] == plmn->idx[1]) &&
(mme_cfg->plmns[config_plmn].idx[2] == plmn->idx[2]) &&
(mme_cfg->plmns[config_plmn].mnc_digits == plmn->mnc_digits))
rc = true;
}
return rc;
}
bool MmeCommonUtils::compare_tac(const uint16_t tac)
{
bool rc = false;
int i = 0;
/*for(i = 0; i < mme_cfg->num_tai; i++)
{
if(mme_cfg->served_tai.tac[i] == tac)
rc = true;
}*/
return rc;
}
bool MmeCommonUtils::isLocalTAI(const struct PLMN *plmn, const short target_tac)
{
bool rc = false;
if(true == compare_plmn_id(plmn))
{
if(true == compare_tac(target_tac))
{
log_msg(LOG_DEBUG, "TAC and PLMN are matching");
rc = true;
}
}
log_msg(LOG_DEBUG, "TAC and PLMN are not matching");
return rc;
}
void MmeCommonUtils::select_neighboring_mme(const struct TAI *tai, int *service_ip_addr)
{
//*service_ip_addr = mme_cfg->target_mme_ip;
return;
}
#endif
uint8_t MmeCommonUtils::select_preferred_int_algo(uint8_t &val)
{
uint8_t result = 0;
for(int i = 0; i < MAX_ALGO_COUNT; i++)
{
if (val & (0x80 >> mme_cfg->integrity_alg_order[i]))
{
result = mme_cfg->integrity_alg_order[i];
break;
}
}
return result;
}
uint8_t MmeCommonUtils::select_preferred_sec_algo(uint8_t &val)
{
uint8_t result = 0;
for(int i = 0; i < MAX_ALGO_COUNT; i++)
{
if (val & (0x80 >> mme_cfg->ciphering_alg_order[i]))
{
result = mme_cfg->ciphering_alg_order[i];
break;
}
}
return result;
}
uint32_t MmeCommonUtils::allocateMtmsi()
{
uint32_t tmsi = 0;
std::default_random_engine generator(time(NULL));
std::uniform_int_distribution<int> temp_fun(0, 1000000);
while(1)
{
tmsi = temp_fun(generator);
if (SubsDataGroupManager::Instance()->findCBWithmTmsi(tmsi) == -1)
break;
}
log_msg(LOG_INFO, "MTMSI allocated is %u", tmsi);
return tmsi;
}
void MmeCommonUtils::formatS1apPlmnId(struct PLMN* plmn_p)
{
/* Lets update plmnId .... What we received from s1ap is : 214365 and what we need on
* s6a/s11/nas interfaces is - 216354*/
unsigned char plmn_byte2 = plmn_p->idx[1];
unsigned char plmn_byte3 = plmn_p->idx[2];
unsigned char mnc3 = plmn_byte3 >> 4; // mnc3
unsigned char mnc2 = plmn_byte3 & 0xf; // mnc2
unsigned char mnc1 = plmn_byte2 >> 4; // mnc1
unsigned char mcc3 = plmn_byte2 & 0xf; //mcc3
// First byte we are not changing mcc2 mcc1
if(mnc1 != 0x0F)
{
plmn_byte2 = (mnc3 << 4) | mcc3; // 2nd byte on NAS - mnc3 mcc3
plmn_byte3 = (mnc2 << 4) | mnc1; // 3rd byte on NAS - <mnc2 mnc1>
plmn_p->idx[1] = plmn_byte2;
plmn_p->idx[2] = plmn_byte3;
}
}
void MmeCommonUtils::getS1apPlmnIdFroms11(struct PLMN* plmn_p)
{
/* we have on s11/nas/s6a - 216354 */
/* s1ap need : 214365 */
unsigned char plmn_byte2 = plmn_p->idx[1];
unsigned char plmn_byte3 = plmn_p->idx[2];
unsigned char mnc3 = plmn_byte2 >> 4; // mnc3
unsigned char mnc2 = plmn_byte3 >> 4; // mnc2
unsigned char mnc1 = plmn_byte3 & 0xf; // mnc1
unsigned char mcc3 = plmn_byte2 & 0xf; //mcc3
// First byte we are not changing mcc2 mcc1
if(mnc1 != 0x0F)
{
plmn_byte2 = (mnc1 << 4) | mcc3;
plmn_byte3 = (mnc3 << 4) | mnc2;
plmn_p->idx[1] = plmn_byte2;
plmn_p->idx[2] = plmn_byte3;
}
}
AttachType MmeCommonUtils::getAttachType(UEContext* ueContext_p,
const struct ue_attach_info& ue_info)
{
log_msg(LOG_INFO, "deriveAttachType");
AttachType attachType = maxAttachType_c;
if(UE_ID_IMSI(ue_info.flags))
{
log_msg(LOG_INFO, "IMSI attach received.");
attachType = imsiAttach_c;
}
else if (UE_ID_GUTI(ue_info.flags))
{
log_msg(LOG_INFO, "GUTI attach received. mTMSI is %u ",
ue_info.mi_guti.m_TMSI);
attachType = unknownGutiAttach_c;
if (isLocalGuti(ue_info.mi_guti))
{
// The guti is allocated by this MME, check if a context exists.
// If the context does not exist, treat as unknown GUTI attach?
log_msg(LOG_INFO, "GUTI is local..");
if (ueContext_p != NULL)
{
if (ueContext_p->getMTmsi() == ue_info.mi_guti.m_TMSI)
{
log_msg(LOG_INFO, "and known");
attachType = knownGutiAttach_c;
}
else
{
log_msg(LOG_INFO, "mTMSI mismatches with UE context. "
"Treat as unknown GUTI attach");
}
}
else
{
log_msg(LOG_INFO, "UE context is null. Unknown GUTI attach triggered");
}
}
else
{
log_msg(LOG_INFO, "GUTI is not local..");
}
}
return attachType;
}
SM::ControlBlock* MmeCommonUtils::findControlBlock(cmn::utils::MsgBuffer* buf)
{
SM::ControlBlock *cb = NULL;
const s1_incoming_msg_header_t* msgData_p = (s1_incoming_msg_header_t*)(buf->getDataPointer());
if(msgData_p == NULL)
{
log_msg(LOG_INFO, "MsgData is NULL .");
return cb;
}
switch (msgData_p->msg_type)
{
case attach_request:
{
const ue_attach_info_t *ue_info = (ue_attach_info_t *)(msgData_p);
if(UE_ID_IMSI(ue_info->flags))
{
log_msg(LOG_INFO, "IMSI attach received.");
uint8_t imsi[BINARY_IMSI_LEN] = {0};
memcpy( imsi, ue_info->IMSI, BINARY_IMSI_LEN );
uint8_t first = imsi[0] >> 4;
imsi[0] = (uint8_t)(( first << 4 ) | 0x0f );
DigitRegister15 IMSIInfo;
IMSIInfo.convertFromBcdArray(imsi);
int cbIndex = SubsDataGroupManager::Instance()->findCBWithimsi(IMSIInfo);
if (cbIndex > 0)
{
log_msg(LOG_DEBUG, "existing cb for IMSI. %s ",IMSIInfo.getDigitsArray());
cb = SubsDataGroupManager::Instance()->findControlBlock(cbIndex);
}
if (cb == NULL)
{
log_msg(LOG_INFO, "create new cb for IMSI %s.", IMSIInfo.getDigitsArray());
cb = SubsDataGroupManager::Instance()->allocateCB();
if(cb == NULL)
{
log_msg(LOG_DEBUG, "create new cb for IMSI failed. %s ",IMSIInfo.getDigitsArray());
return nullptr;
}
cb->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}
else if (UE_ID_GUTI(ue_info->flags))
{
log_msg(LOG_INFO, "GUTI attach received.");
if (isLocalGuti(ue_info->mi_guti))
{
log_msg(LOG_INFO, "GUTI is local.");
int cbIndex = SubsDataGroupManager::Instance()->findCBWithmTmsi(ue_info->mi_guti.m_TMSI);
if (cbIndex > 0)
{
cb = SubsDataGroupManager::Instance()->findControlBlock(cbIndex);
}
else
{
log_msg(LOG_ERROR, "Failed to find control block with mTmsi.");
// allocate new cb and proceed?
cb = SubsDataGroupManager::Instance()->allocateCB();
cb->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}
else
{
cb = SubsDataGroupManager::Instance()->allocateCB();
cb->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}
break;
}
case service_request:
{
int cbIndex = SubsDataGroupManager::Instance()->findCBWithmTmsi(msgData_p->ue_idx);
if (cbIndex > 0)
{
cb = SubsDataGroupManager::Instance()->findControlBlock(cbIndex);
}
else
{
log_msg(LOG_INFO, "Failed to find control block with mTmsi.");
}
if (cb == NULL)
{
log_msg(LOG_INFO, "Failed to find control block using mtmsi %d."
" Allocate a temporary control block", msgData_p->ue_idx);
// Respond with Service Reject from default Service Request event handler
cb = SubsDataGroupManager::Instance()->allocateCB();
cb->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
break;
}
case detach_request:
{
const detach_req_Q_msg_t *detach_Req = (const detach_req_Q_msg_t *)(msgData_p);
int cbIndex = SubsDataGroupManager::Instance()->findCBWithmTmsi(detach_Req->ue_m_tmsi);
if (cbIndex > 0)
{
cb = SubsDataGroupManager::Instance()->findControlBlock(cbIndex);
}
else
{
log_msg(LOG_INFO, "Failed to find control block with mTmsi. %d", detach_Req->ue_m_tmsi);
}
break;
}
case tau_request:
{
const tauReq_Q_msg_t *tau_Req = (const tauReq_Q_msg_t *)(msgData_p);
int cbIndex = SubsDataGroupManager::Instance()->findCBWithmTmsi(tau_Req->ue_m_tmsi);
if (cbIndex > 0)
{
cb = SubsDataGroupManager::Instance()->findControlBlock(cbIndex);
}
else
{
log_msg(LOG_INFO, "Failed to find control block using mTmsi %d."
" Allocate a temporary control block", tau_Req->ue_m_tmsi);
// Respond with TAU Reject from default TAU event handler
cb = SubsDataGroupManager::Instance()->allocateCB();
cb->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
break;
}
default:
{
log_msg(LOG_INFO, "Unhandled message type %d ", msgData_p->msg_type);
}
}
return cb;
}
ControlBlock* MmeCommonUtils::findControlBlockForS11Msg(cmn::utils::MsgBuffer* msg_p)
{
ControlBlock* cb_p = NULL;
const gtp_incoming_msg_data_t* msgData_p = (gtp_incoming_msg_data_t*)(msg_p->getDataPointer());
if(msgData_p == NULL)
{
log_msg(LOG_INFO, "GTP message data is NULL .");
return cb_p;
}
switch (msgData_p->msg_type)
{
case downlink_data_notification:
{
const struct ddn_Q_msg* ddn = (const struct ddn_Q_msg*) (msg_p->getDataPointer());
if (ddn->s11_mme_cp_teid == 0)
{
log_msg(LOG_INFO, "UE Index in DDN message data is 0.");
return cb_p;
}
cb_p = SubsDataGroupManager::Instance()->findControlBlock(ddn->s11_mme_cp_teid);
if (cb_p == NULL)
{
log_msg(LOG_INFO, "Failed to find control block using index %d."
" Allocate a temporary control block", ddn->s11_mme_cp_teid);
// Respond with DDN failure from default DDN event handler
cb_p = SubsDataGroupManager::Instance()->allocateCB();
cb_p->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}break;
case create_bearer_request:
{
const struct cb_req_Q_msg * cbr = (const struct cb_req_Q_msg *) (msg_p->getDataPointer());
if (cbr->s11_mme_cp_teid == 0)
{
log_msg(LOG_INFO, "UE Index in CB Req message data is 0.");
return cb_p;
}
cb_p = SubsDataGroupManager::Instance()->findControlBlock(cbr->s11_mme_cp_teid);
if (cb_p == NULL)
{
log_msg(LOG_INFO, "Failed to find control block using index %d."
" Allocate a temporary control block", cbr->s11_mme_cp_teid);
// Respond with CB Resp from default CB Req event handler
cb_p = SubsDataGroupManager::Instance()->allocateCB();
cb_p->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}break;
case delete_bearer_request:
{
const struct db_req_Q_msg * dbr = (const struct db_req_Q_msg *) (msg_p->getDataPointer());
if (dbr->s11_mme_cp_teid == 0)
{
log_msg(LOG_INFO, "UE Index in DB Req message data is 0.");
return cb_p;
}
cb_p = SubsDataGroupManager::Instance()->findControlBlock(dbr->s11_mme_cp_teid);
if (cb_p == NULL)
{
log_msg(LOG_INFO, "Failed to find control block using index %d."
" Allocate a temporary control block", dbr->s11_mme_cp_teid);
// Respond with DB Resp from default DB Req event handler
cb_p = SubsDataGroupManager::Instance()->allocateCB();
cb_p->addTempDataBlock(DefaultMmeProcedureCtxt::Instance());
}
}break;
default:
{
log_msg(LOG_INFO, "Unhandled message type");
}
}
return cb_p;
}
bool MmeCommonUtils::isEmmInfoRequired(ControlBlock& cb, UEContext& ueCtxt, MmeProcedureCtxt& procCtxt)
{
bool rc = false;
if (procCtxt.getCtxtType() == attach_c)
{
MmeAttachProcedureCtxt& attachCtxt = dynamic_cast<MmeAttachProcedureCtxt &>(procCtxt);
if (attachCtxt.getAttachType() == imsiAttach_c)
{
rc = true;
}
}
return rc;
}
bool MmeCommonUtils::isUeNRCapable(UEContext &ueCtxt)
{
bool rc;
if (!ueCtxt.getUeNetCapab().ue_net_capab_m.u.bits.dcnr) {
log_msg(LOG_DEBUG, "UE does not support dual connectivity");
rc = false;
} else if (!mme_cfg->feature_list.dcnr_support) {
log_msg(LOG_DEBUG,"MME local config does not allow dual connectivity");
rc = false;
} else if (!(ueCtxt.getHssFeatList2().feature_list & nrAsSecRatBitMask_c)) {
log_msg(LOG_DEBUG,"HSS does not support dual connectivity feature");
rc = false;
} else if (ueCtxt.getAccessRestrictionData() & nrAsSecRatInEutranNotAllowedBitMask_c) {
log_msg(LOG_DEBUG,"hss informed about access restriction for this UE");
rc = false;
} else {
log_msg(LOG_DEBUG,"All well, this UE can use DCNR");
rc = true;
}
return rc;
}
| 28.193613 | 105 | 0.632212 | dksan23 |
7df37ff7b62b2e446ee6b4b53d8b3d57b05d880c | 695 | cpp | C++ | 112-path-sum/112-path-sum.cpp | SouvikChan/-Leetcode_Souvik | cc4b72cb4a14a1c6b8be8bd8390de047443fe008 | [
"MIT"
] | null | null | null | 112-path-sum/112-path-sum.cpp | SouvikChan/-Leetcode_Souvik | cc4b72cb4a14a1c6b8be8bd8390de047443fe008 | [
"MIT"
] | null | null | null | 112-path-sum/112-path-sum.cpp | SouvikChan/-Leetcode_Souvik | cc4b72cb4a14a1c6b8be8bd8390de047443fe008 | [
"MIT"
] | null | null | null | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool hasPathSum(TreeNode* root, int targetSum) {
if(root==NULL)
return false;
if(root->left==NULL and root->right==NULL)
return (targetSum-root->val)==0;
return hasPathSum(root->left, targetSum-root->val) || hasPathSum(root->right,targetSum-root->val);
}
}; | 33.095238 | 106 | 0.592806 | SouvikChan |
7df3ff31a0f12af5f99989e23e969a1563996568 | 2,319 | cpp | C++ | FW/SC/scene.cpp | JAntn/wblocks | e8aa383882b4726f6f7cca7213fa49e9e80d990f | [
"MIT"
] | null | null | null | FW/SC/scene.cpp | JAntn/wblocks | e8aa383882b4726f6f7cca7213fa49e9e80d990f | [
"MIT"
] | null | null | null | FW/SC/scene.cpp | JAntn/wblocks | e8aa383882b4726f6f7cca7213fa49e9e80d990f | [
"MIT"
] | null | null | null | #include "FW/SC/scene.h"
#include "FW/tools.h"
#include "FW/ST/state_writer.h"
#include "FW/RC/record.h"
#include "FW/SC/scene_line.h"
////////////////////////////////////////////////////////////////////////
/// Static
long TypeScene::m_IdCount = 0;
QString TypeScene::GenerateId()
{
return QString().setNum( m_IdCount++ );
}
QString TypeScene::IdCount()
{
return QString().setNum( m_IdCount );
}
////////////////////////////////////////////////////////////////////////
TypeScene::TypeScene( TypeController& controller, TypeVariant* parent ) :
TypeVariant( parent ),
m_Controller( &controller ),
m_TopZ( 0 )
{
m_Graphics = new QGraphicsScene();
}
TypeScene::~TypeScene()
{
delete m_Graphics;
}
TypeSceneItem* TypeScene::NewItem( TypeStateWriter& state )
{
return new TypeSceneItem( *this, state );
}
TypeSceneItem* TypeScene::NewItem( TypeRecord& record )
{
return new TypeSceneItem( *this, record, 100 + ( qrand() % 40 - 80 ), 100 + ( qrand() % 40 - 80 ) );
}
TypeSceneItem* TypeScene::NewItem( TypeRecord& record, qreal x, qreal y, qreal z )
{
return new TypeSceneItem( *this, record, x, y, z );
}
QList<TypeSceneItem*> TypeScene::FromRecord( TypeRecord& record ) const
{
QList<TypeSceneItem*> result;
for( TypeSceneItem* item : Items() )
{
if( & item->Record() == & record )
result.append( item );
}
return result;
}
void TypeScene::Clear()
{
Graphics().clear();
}
int TypeScene::Size()
{
return Items().size();
}
void TypeScene::BringFront( TypeSceneItem& item )
{
m_TopZ += 0.01;
item.setZValue( m_TopZ );
}
void TypeScene::UpdateView()
{
// Update lines
ClearLines();
for( TypeSceneItem* from : Items() )
{
if( from->Record().Struct() != 0 )
{
for( TypeVariantPtr<TypeRecord> record : *from->Record().Struct() )
{
for( TypeSceneItem* target : Items() )
{
TypeRecord* record_target = &target->Record();
if( record == record_target )
m_Lines.append( new TypeSceneLine( *from, *target, Qt::blue ) );
}
}
}
}
}
void TypeScene::ClearLines()
{
for( TypeSceneLine* line : Lines() )
delete line;
}
| 20.705357 | 104 | 0.552393 | JAntn |
7dfa357ea81a103eef3e76c1f4dc78093c7e9783 | 468 | hpp | C++ | lib/cml/hal/peripherals/RS485.hpp | msemegen/CML | f37e20f0add711c743b69607d39aa5ab0680cf7e | [
"MIT"
] | 23 | 2020-07-16T21:52:38.000Z | 2022-03-13T18:24:16.000Z | lib/cml/hal/peripherals/RS485.hpp | msemegen/CML | f37e20f0add711c743b69607d39aa5ab0680cf7e | [
"MIT"
] | 16 | 2019-12-28T01:14:44.000Z | 2021-04-15T14:40:07.000Z | lib/cml/hal/peripherals/RS485.hpp | msemegen/CML | f37e20f0add711c743b69607d39aa5ab0680cf7e | [
"MIT"
] | 5 | 2020-07-17T17:48:50.000Z | 2022-03-25T16:06:52.000Z | #pragma once
/*
* Name: RS485.hpp
*
* Copyright (c) Mateusz Semegen and contributors. All rights reserved.
* Licensed under the MIT license. See LICENSE file in the project root for details.
*/
#ifdef STM32L4
#include <soc/m4/stm32l4/peripherals/RS485.hpp>
#endif // STM32L4
namespace cml {
namespace hal {
#ifdef STM32L4
using RS485 = soc::m4::stm32l4::peripherals::RS485;
#endif // STM32L4
} // namespace hal
} // namespace cml
| 20.347826 | 87 | 0.675214 | msemegen |
b4017fd6a90ad0f9f060e68d9500d2c4da784f73 | 40,053 | cpp | C++ | be/src/olap/reader.cpp | spaces-X/doris-vectorized | 73ff3f3c0786c79a154e714fde56c812ac3f4f8f | [
"Apache-2.0"
] | null | null | null | be/src/olap/reader.cpp | spaces-X/doris-vectorized | 73ff3f3c0786c79a154e714fde56c812ac3f4f8f | [
"Apache-2.0"
] | null | null | null | be/src/olap/reader.cpp | spaces-X/doris-vectorized | 73ff3f3c0786c79a154e714fde56c812ac3f4f8f | [
"Apache-2.0"
] | null | null | null | // 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.
#include "olap/reader.h"
#include <parallel_hashmap/phmap.h>
#include <boost/algorithm/string/case_conv.hpp>
#include <charconv>
#include <unordered_set>
#include "olap/bloom_filter_predicate.h"
#include "olap/collect_iterator.h"
#include "vec/olap/vcollect_iterator.h"
#include "olap/comparison_predicate.h"
#include "olap/in_list_predicate.h"
#include "olap/null_predicate.h"
#include "olap/row.h"
#include "olap/row_block.h"
#include "olap/row_cursor.h"
#include "olap/rowset/beta_rowset_reader.h"
#include "olap/rowset/column_data.h"
#include "olap/schema.h"
#include "olap/storage_engine.h"
#include "olap/tablet.h"
#include "runtime/mem_pool.h"
#include "runtime/mem_tracker.h"
#include "runtime/string_value.hpp"
#include "util/date_func.h"
#include "util/mem_util.hpp"
using std::nothrow;
using std::set;
using std::vector;
namespace doris {
void ReaderParams::check_validation() const {
if (UNLIKELY(version.first == -1)) {
LOG(FATAL) << "version is not set. tablet=" << tablet->full_name();
}
}
std::string ReaderParams::to_string() const {
std::stringstream ss;
ss << "tablet=" << tablet->full_name() << " reader_type=" << reader_type
<< " aggregation=" << aggregation << " version=" << version << " start_key_include=" << start_key_include
<< " end_key_include=" << end_key_include;
for (const auto& key : start_key) {
ss << " keys=" << key;
}
for (const auto& key : end_key) {
ss << " end_keys=" << key;
}
for (auto& condition : conditions) {
ss << " conditions=" << apache::thrift::ThriftDebugString(condition);
}
return ss.str();
}
KeysParam::~KeysParam() {
for (auto start_key : start_keys) {
SAFE_DELETE(start_key);
}
for (auto end_key : end_keys) {
SAFE_DELETE(end_key);
}
}
std::string KeysParam::to_string() const {
std::stringstream ss;
ss << "start_key_include=" << start_key_include << " end_key_include=" << end_key_include;
for (auto start_key : start_keys) {
ss << " keys=" << start_key->to_string();
}
for (auto end_key : end_keys) {
ss << " end_keys=" << end_key->to_string();
}
return ss.str();
}
Reader::Reader() : _collect_iter(new CollectIterator()) {}
Reader::~Reader() {
VLOG_NOTICE << "merged rows:" << _merged_rows;
_conditions.finalize();
if (!_all_conditions.empty()) {
_all_conditions.finalize();
}
_delete_handler.finalize();
for (auto pred : _col_predicates) {
delete pred;
}
for (auto pred : _value_col_predicates) {
delete pred;
}
}
OLAPStatus Reader::init(const ReaderParams& read_params) {
// TODO(yingchun): monitor
_tracker.reset(new MemTracker(-1, read_params.tablet->full_name()));
_predicate_mem_pool.reset(new MemPool(_tracker.get()));
OLAPStatus res = _init_params(read_params);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to init reader when init params. res:" << res
<< ", tablet_id:" << read_params.tablet->tablet_id()
<< ", schema_hash:" << read_params.tablet->schema_hash()
<< ", reader type:" << read_params.reader_type
<< ", version:" << read_params.version;
return res;
}
std::vector<RowsetReaderSharedPtr> rs_readers;
res = _capture_rs_readers(read_params, &rs_readers);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to init reader when _capture_rs_readers. res:" << res
<< ", tablet_id:" << read_params.tablet->tablet_id()
<< ", schema_hash:" << read_params.tablet->schema_hash()
<< ", reader_type:" << read_params.reader_type
<< ", version:" << read_params.version;
return res;
}
return OLAP_SUCCESS;
}
// When only one rowset has data, and this rowset is nonoverlapping, we can read directly without aggregation
bool Reader::_optimize_for_single_rowset(const std::vector<RowsetReaderSharedPtr>& rs_readers) {
bool has_delete_rowset = false;
bool has_overlapping = false;
int nonoverlapping_count = 0;
for (const auto& rs_reader : rs_readers) {
if (rs_reader->rowset()->rowset_meta()->delete_flag()) {
has_delete_rowset = true;
break;
}
if (rs_reader->rowset()->rowset_meta()->num_rows() > 0) {
if (rs_reader->rowset()->rowset_meta()->is_segments_overlapping()) {
// when there are overlapping segments, can not do directly read
has_overlapping = true;
break;
} else if (++nonoverlapping_count > 1) {
break;
}
}
}
return !has_overlapping && nonoverlapping_count == 1 && !has_delete_rowset;
}
OLAPStatus Reader::_capture_rs_readers(const ReaderParams& read_params,
std::vector<RowsetReaderSharedPtr>* valid_rs_readers) {
const std::vector<RowsetReaderSharedPtr>* rs_readers = &read_params.rs_readers;
if (rs_readers->empty()) {
LOG(WARNING) << "fail to acquire data sources. tablet=" << _tablet->full_name();
return OLAP_ERR_VERSION_NOT_EXIST;
}
bool eof = false;
bool is_lower_key_included = _keys_param.start_key_include;
bool is_upper_key_included = _keys_param.end_key_include;
for (int i = 0; i < _keys_param.start_keys.size(); ++i) {
// lower bound
RowCursor* start_key = _keys_param.start_keys[i];
RowCursor* end_key = _keys_param.end_keys[i];
if (!is_lower_key_included) {
if (end_key != nullptr && compare_row_key(*start_key, *end_key) >= 0) {
VLOG_NOTICE << "return EOF when lower key not include"
<< ", start_key=" << start_key->to_string()
<< ", end_key=" << end_key->to_string();
eof = true;
break;
}
} else {
if (end_key != nullptr && compare_row_key(*start_key, *end_key) > 0) {
VLOG_NOTICE << "return EOF when lower key include="
<< ", start_key=" << start_key->to_string()
<< ", end_key=" << end_key->to_string();
eof = true;
break;
}
}
_is_lower_keys_included.push_back(is_lower_key_included);
_is_upper_keys_included.push_back(is_upper_key_included);
}
if (eof) {
return OLAP_SUCCESS;
}
bool need_ordered_result = true;
if (read_params.reader_type == READER_QUERY) {
if (_tablet->tablet_schema().keys_type() == DUP_KEYS) {
// duplicated keys are allowed, no need to merge sort keys in rowset
need_ordered_result = false;
}
if (_aggregation) {
// compute engine will aggregate rows with the same key,
// it's ok for rowset to return unordered result
need_ordered_result = false;
}
}
_reader_context.reader_type = read_params.reader_type;
_reader_context.tablet_schema = &_tablet->tablet_schema();
_reader_context.need_ordered_result = need_ordered_result;
_reader_context.return_columns = &_return_columns;
_reader_context.seek_columns = &_seek_columns;
_reader_context.load_bf_columns = &_load_bf_columns;
_reader_context.load_bf_all_columns = &_load_bf_all_columns;
_reader_context.conditions = &_conditions;
_reader_context.all_conditions = &_all_conditions;
_reader_context.predicates = &_col_predicates;
_reader_context.value_predicates = &_value_col_predicates;
_reader_context.lower_bound_keys = &_keys_param.start_keys;
_reader_context.is_lower_keys_included = &_is_lower_keys_included;
_reader_context.upper_bound_keys = &_keys_param.end_keys;
_reader_context.is_upper_keys_included = &_is_upper_keys_included;
_reader_context.delete_handler = &_delete_handler;
_reader_context.stats = &_stats;
_reader_context.runtime_state = read_params.runtime_state;
_reader_context.use_page_cache = read_params.use_page_cache;
_reader_context.sequence_id_idx = _sequence_col_idx;
*valid_rs_readers = *rs_readers;
return OLAP_SUCCESS;
}
OLAPStatus Reader::_init_params(const ReaderParams& read_params) {
read_params.check_validation();
_aggregation = read_params.aggregation;
_need_agg_finalize = read_params.need_agg_finalize;
_reader_type = read_params.reader_type;
_tablet = read_params.tablet;
_init_conditions_param(read_params);
_init_load_bf_columns(read_params);
OLAPStatus res = _init_delete_condition(read_params);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init delete param. [res=%d]", res);
return res;
}
res = _init_return_columns(read_params);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init return columns. [res=%d]", res);
return res;
}
res = _init_keys_param(read_params);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to init keys param. res=" << res;
return res;
}
_init_seek_columns();
_collect_iter->init(this);
if (_tablet->tablet_schema().has_sequence_col()) {
auto sequence_col_idx = _tablet->tablet_schema().sequence_col_idx();
DCHECK_NE(sequence_col_idx, -1);
for (auto col : _return_columns) {
// query has sequence col
if (col == sequence_col_idx) {
_sequence_col_idx = sequence_col_idx;
break;
}
}
}
return res;
}
OLAPStatus Reader::_init_return_columns(const ReaderParams& read_params) {
if (read_params.reader_type == READER_QUERY) {
_return_columns = read_params.return_columns;
if (!_delete_handler.empty()) {
// We need to fetch columns which there are deletion conditions on them.
set<uint32_t> column_set(_return_columns.begin(), _return_columns.end());
for (const auto& conds : _delete_handler.get_delete_conditions()) {
for (const auto& cond_column : conds.del_cond->columns()) {
if (column_set.find(cond_column.first) == column_set.end()) {
column_set.insert(cond_column.first);
_return_columns.push_back(cond_column.first);
}
}
}
}
for (auto id : read_params.return_columns) {
if (_tablet->tablet_schema().column(id).is_key()) {
_key_cids.push_back(id);
} else {
_value_cids.push_back(id);
}
}
} else if (read_params.return_columns.empty()) {
for (size_t i = 0; i < _tablet->tablet_schema().num_columns(); ++i) {
_return_columns.push_back(i);
if (_tablet->tablet_schema().column(i).is_key()) {
_key_cids.push_back(i);
} else {
_value_cids.push_back(i);
}
}
VLOG_NOTICE << "return column is empty, using full column as default.";
} else if (read_params.reader_type == READER_CHECKSUM) {
_return_columns = read_params.return_columns;
for (auto id : read_params.return_columns) {
if (_tablet->tablet_schema().column(id).is_key()) {
_key_cids.push_back(id);
} else {
_value_cids.push_back(id);
}
}
} else {
OLAP_LOG_WARNING("fail to init return columns. [reader_type=%d return_columns_size=%u]",
read_params.reader_type, read_params.return_columns.size());
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
std::sort(_key_cids.begin(), _key_cids.end(), std::greater<uint32_t>());
return OLAP_SUCCESS;
}
void Reader::_init_seek_columns() {
std::unordered_set<uint32_t> column_set(_return_columns.begin(), _return_columns.end());
for (auto& it : _conditions.columns()) {
column_set.insert(it.first);
}
size_t max_key_column_count = 0;
for (const auto& key : _keys_param.start_keys) {
max_key_column_count = std::max(max_key_column_count, key->field_count());
}
for (const auto& key : _keys_param.end_keys) {
max_key_column_count = std::max(max_key_column_count, key->field_count());
}
for (size_t i = 0; i < _tablet->tablet_schema().num_columns(); i++) {
if (i < max_key_column_count || column_set.find(i) != column_set.end()) {
_seek_columns.push_back(i);
}
}
}
OLAPStatus Reader::_init_keys_param(const ReaderParams& read_params) {
if (read_params.start_key.empty()) {
return OLAP_SUCCESS;
}
_keys_param.start_key_include = read_params.start_key_include;
_keys_param.end_key_include = read_params.end_key_include;
size_t start_key_size = read_params.start_key.size();
_keys_param.start_keys.resize(start_key_size, nullptr);
size_t scan_key_size = read_params.start_key.front().size();
if (scan_key_size > _tablet->tablet_schema().num_columns()) {
LOG(WARNING)
<< "Input param are invalid. Column count is bigger than num_columns of schema. "
<< "column_count=" << scan_key_size
<< ", schema.num_columns=" << _tablet->tablet_schema().num_columns();
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
std::vector<uint32_t> columns(scan_key_size);
std::iota(columns.begin(), columns.end(), 0);
std::shared_ptr<Schema> schema =
std::make_shared<Schema>(_tablet->tablet_schema().columns(), columns);
for (size_t i = 0; i < start_key_size; ++i) {
if (read_params.start_key[i].size() != scan_key_size) {
OLAP_LOG_WARNING("The start_key.at(%ld).size == %ld, not equals the %ld", i,
read_params.start_key[i].size(), scan_key_size);
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
if ((_keys_param.start_keys[i] = new (nothrow) RowCursor()) == nullptr) {
OLAP_LOG_WARNING("fail to new RowCursor!");
return OLAP_ERR_MALLOC_ERROR;
}
OLAPStatus res = _keys_param.start_keys[i]->init_scan_key(
_tablet->tablet_schema(), read_params.start_key[i].values(), schema);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init row cursor. [res=%d]", res);
return res;
}
res = _keys_param.start_keys[i]->from_tuple(read_params.start_key[i]);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init row cursor from Keys. [res=%d key_index=%ld]", res, i);
return res;
}
}
size_t end_key_size = read_params.end_key.size();
_keys_param.end_keys.resize(end_key_size, nullptr);
for (size_t i = 0; i < end_key_size; ++i) {
if (read_params.end_key[i].size() != scan_key_size) {
OLAP_LOG_WARNING("The end_key.at(%ld).size == %ld, not equals the %ld", i,
read_params.end_key[i].size(), scan_key_size);
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
if ((_keys_param.end_keys[i] = new (nothrow) RowCursor()) == nullptr) {
OLAP_LOG_WARNING("fail to new RowCursor!");
return OLAP_ERR_MALLOC_ERROR;
}
OLAPStatus res = _keys_param.end_keys[i]->init_scan_key(
_tablet->tablet_schema(), read_params.end_key[i].values(), schema);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init row cursor. [res=%d]", res);
return res;
}
res = _keys_param.end_keys[i]->from_tuple(read_params.end_key[i]);
if (res != OLAP_SUCCESS) {
OLAP_LOG_WARNING("fail to init row cursor from Keys. [res=%d key_index=%ld]", res, i);
return res;
}
}
//TODO:check the valid of start_key and end_key.(eg. start_key <= end_key)
return OLAP_SUCCESS;
}
void Reader::_init_conditions_param(const ReaderParams& read_params) {
_conditions.set_tablet_schema(&_tablet->tablet_schema());
_all_conditions.set_tablet_schema(&_tablet->tablet_schema());
for (const auto& condition : read_params.conditions) {
ColumnPredicate* predicate = _parse_to_predicate(condition);
if (predicate != nullptr) {
if (_tablet->tablet_schema()
.column(_tablet->field_index(condition.column_name))
.aggregation() != FieldAggregationMethod::OLAP_FIELD_AGGREGATION_NONE) {
_value_col_predicates.push_back(predicate);
} else {
_col_predicates.push_back(predicate);
OLAPStatus status = _conditions.append_condition(condition);
DCHECK_EQ(OLAP_SUCCESS, status);
}
OLAPStatus status = _all_conditions.append_condition(condition);
DCHECK_EQ(OLAP_SUCCESS, status);
}
}
// Only key column bloom filter will push down to storage engine
for (const auto& filter : read_params.bloom_filters) {
_col_predicates.emplace_back(_parse_to_predicate(filter));
}
}
#define COMPARISON_PREDICATE_CONDITION_VALUE(NAME, PREDICATE) \
ColumnPredicate* Reader::_new_##NAME##_pred(const TabletColumn& column, int index, \
const std::string& cond, bool opposite) const { \
ColumnPredicate* predicate = nullptr; \
switch (column.type()) { \
case OLAP_FIELD_TYPE_TINYINT: { \
int8_t value = 0; \
std::from_chars(cond.data(), cond.data() + cond.size(), value); \
predicate = new PREDICATE<int8_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_SMALLINT: { \
int16_t value = 0; \
std::from_chars(cond.data(), cond.data() + cond.size(), value); \
predicate = new PREDICATE<int16_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_INT: { \
int32_t value = 0; \
std::from_chars(cond.data(), cond.data() + cond.size(), value); \
predicate = new PREDICATE<int32_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_BIGINT: { \
int64_t value = 0; \
std::from_chars(cond.data(), cond.data() + cond.size(), value); \
predicate = new PREDICATE<int64_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_LARGEINT: { \
int128_t value = 0; \
StringParser::ParseResult result; \
value = StringParser::string_to_int<__int128>(cond.data(), cond.size(), &result); \
predicate = new PREDICATE<int128_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_DECIMAL: { \
decimal12_t value = {0, 0}; \
value.from_string(cond); \
predicate = new PREDICATE<decimal12_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_CHAR: { \
StringValue value; \
size_t length = std::max(static_cast<size_t>(column.length()), cond.length()); \
char* buffer = reinterpret_cast<char*>(_predicate_mem_pool->allocate(length)); \
memset(buffer, 0, length); \
memory_copy(buffer, cond.c_str(), cond.length()); \
value.len = length; \
value.ptr = buffer; \
predicate = new PREDICATE<StringValue>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_VARCHAR: \
case OLAP_FIELD_TYPE_STRING: { \
StringValue value; \
int32_t length = cond.length(); \
char* buffer = reinterpret_cast<char*>(_predicate_mem_pool->allocate(length)); \
memory_copy(buffer, cond.c_str(), length); \
value.len = length; \
value.ptr = buffer; \
predicate = new PREDICATE<StringValue>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_DATE: { \
uint24_t value = timestamp_from_date(cond); \
predicate = new PREDICATE<uint24_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_DATETIME: { \
uint64_t value = timestamp_from_datetime(cond); \
predicate = new PREDICATE<uint64_t>(index, value, opposite); \
break; \
} \
case OLAP_FIELD_TYPE_BOOL: { \
int32_t ivalue = 0; \
auto result = std::from_chars(cond.data(), cond.data() + cond.size(), ivalue); \
bool value = false; \
if (result.ec == std::errc()) { \
if (ivalue == 0) { \
value = false; \
} else { \
value = true; \
} \
} else { \
StringParser::ParseResult parse_result; \
value = StringParser::string_to_bool(cond.data(), cond.size(), &parse_result); \
} \
predicate = new PREDICATE<bool>(index, value, opposite); \
break; \
} \
default: \
break; \
} \
\
return predicate; \
}
COMPARISON_PREDICATE_CONDITION_VALUE(eq, EqualPredicate)
COMPARISON_PREDICATE_CONDITION_VALUE(ne, NotEqualPredicate)
COMPARISON_PREDICATE_CONDITION_VALUE(lt, LessPredicate)
COMPARISON_PREDICATE_CONDITION_VALUE(le, LessEqualPredicate)
COMPARISON_PREDICATE_CONDITION_VALUE(gt, GreaterPredicate)
COMPARISON_PREDICATE_CONDITION_VALUE(ge, GreaterEqualPredicate)
ColumnPredicate* Reader::_parse_to_predicate(
const std::pair<std::string, std::shared_ptr<IBloomFilterFuncBase>>& bloom_filter) {
int32_t index = _tablet->field_index(bloom_filter.first);
if (index < 0) {
return nullptr;
}
const TabletColumn& column = _tablet->tablet_schema().column(index);
return BloomFilterColumnPredicateFactory::create_column_predicate(index, bloom_filter.second,
column.type());
}
ColumnPredicate* Reader::_parse_to_predicate(const TCondition& condition, bool opposite) const {
// TODO: not equal and not in predicate is not pushed down
int32_t index = _tablet->field_index(condition.column_name);
if (index < 0) {
return nullptr;
}
const TabletColumn& column = _tablet->tablet_schema().column(index);
ColumnPredicate* predicate = nullptr;
if ((condition.condition_op == "*=" || condition.condition_op == "!*=" ||
condition.condition_op == "=" || condition.condition_op == "!=") &&
condition.condition_values.size() == 1) {
predicate = condition.condition_op == "*=" || condition.condition_op == "="
? _new_eq_pred(column, index, condition.condition_values[0], opposite)
: _new_ne_pred(column, index, condition.condition_values[0], opposite);
} else if (condition.condition_op == "<<") {
predicate = _new_lt_pred(column, index, condition.condition_values[0], opposite);
} else if (condition.condition_op == "<=") {
predicate = _new_le_pred(column, index, condition.condition_values[0], opposite);
} else if (condition.condition_op == ">>") {
predicate = _new_gt_pred(column, index, condition.condition_values[0], opposite);
} else if (condition.condition_op == ">=") {
predicate = _new_ge_pred(column, index, condition.condition_values[0], opposite);
} else if ((condition.condition_op == "*=" || condition.condition_op == "!*=") &&
condition.condition_values.size() > 1) {
switch (column.type()) {
case OLAP_FIELD_TYPE_TINYINT: {
phmap::flat_hash_set<int8_t> values;
int8_t value = 0;
for (auto& cond_val : condition.condition_values) {
std::from_chars(cond_val.data(), cond_val.data() + cond_val.size(), value);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<int8_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<int8_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_SMALLINT: {
phmap::flat_hash_set<int16_t> values;
int16_t value = 0;
for (auto& cond_val : condition.condition_values) {
std::from_chars(cond_val.data(), cond_val.data() + cond_val.size(), value);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<int16_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<int16_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_INT: {
phmap::flat_hash_set<int32_t> values;
int32_t value = 0;
for (auto& cond_val : condition.condition_values) {
std::from_chars(cond_val.data(), cond_val.data() + cond_val.size(), value);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<int32_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<int32_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_BIGINT: {
phmap::flat_hash_set<int64_t> values;
int64_t value = 0;
for (auto& cond_val : condition.condition_values) {
std::from_chars(cond_val.data(), cond_val.data() + cond_val.size(), value);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<int64_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<int64_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_LARGEINT: {
phmap::flat_hash_set<int128_t> values;
int128_t value = 0;
StringParser::ParseResult result;
for (auto& cond_val : condition.condition_values) {
value = StringParser::string_to_int<__int128>(cond_val.c_str(), cond_val.size(),
&result);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<int128_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<int128_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_DECIMAL: {
phmap::flat_hash_set<decimal12_t> values;
for (auto& cond_val : condition.condition_values) {
decimal12_t value = {0, 0};
value.from_string(cond_val);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<decimal12_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<decimal12_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_CHAR: {
phmap::flat_hash_set<StringValue> values;
for (auto& cond_val : condition.condition_values) {
StringValue value;
size_t length = std::max(static_cast<size_t>(column.length()), cond_val.length());
char* buffer = reinterpret_cast<char*>(_predicate_mem_pool->allocate(length));
memset(buffer, 0, length);
memory_copy(buffer, cond_val.c_str(), cond_val.length());
value.len = length;
value.ptr = buffer;
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<StringValue>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<StringValue>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_VARCHAR:
case OLAP_FIELD_TYPE_STRING:{
phmap::flat_hash_set<StringValue> values;
for (auto& cond_val : condition.condition_values) {
StringValue value;
int32_t length = cond_val.length();
char* buffer = reinterpret_cast<char*>(_predicate_mem_pool->allocate(length));
memory_copy(buffer, cond_val.c_str(), length);
value.len = length;
value.ptr = buffer;
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<StringValue>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<StringValue>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_DATE: {
phmap::flat_hash_set<uint24_t> values;
for (auto& cond_val : condition.condition_values) {
uint24_t value = timestamp_from_date(cond_val);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<uint24_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<uint24_t>(index, std::move(values), opposite);
}
break;
}
case OLAP_FIELD_TYPE_DATETIME: {
phmap::flat_hash_set<uint64_t> values;
for (auto& cond_val : condition.condition_values) {
uint64_t value = timestamp_from_datetime(cond_val);
values.insert(value);
}
if (condition.condition_op == "*=") {
predicate = new InListPredicate<uint64_t>(index, std::move(values), opposite);
} else {
predicate = new NotInListPredicate<uint64_t>(index, std::move(values), opposite);
}
break;
}
// OLAP_FIELD_TYPE_BOOL is not valid in this case.
default:
break;
}
} else if (boost::to_lower_copy(condition.condition_op) == "is") {
predicate = new NullPredicate(
index, boost::to_lower_copy(condition.condition_values[0]) == "null", opposite);
}
return predicate;
}
void Reader::_init_load_bf_columns(const ReaderParams& read_params) {
_init_load_bf_columns(read_params, &_conditions, &_load_bf_columns);
_init_load_bf_columns(read_params, &_all_conditions, &_load_bf_all_columns);
}
void Reader::_init_load_bf_columns(const ReaderParams& read_params, Conditions* conditions,
std::set<uint32_t>* load_bf_columns) {
// add all columns with condition to load_bf_columns
for (const auto& cond_column : conditions->columns()) {
if (!_tablet->tablet_schema().column(cond_column.first).is_bf_column()) {
continue;
}
for (const auto& cond : cond_column.second->conds()) {
if (cond->op == OP_EQ ||
(cond->op == OP_IN && cond->operand_set.size() < MAX_OP_IN_FIELD_NUM)) {
load_bf_columns->insert(cond_column.first);
}
}
}
// remove columns which have same value between start_key and end_key
int min_scan_key_len = _tablet->tablet_schema().num_columns();
for (const auto& start_key : read_params.start_key) {
min_scan_key_len = std::min(min_scan_key_len, static_cast<int>(start_key.size()));
}
for (const auto& end_key : read_params.end_key) {
min_scan_key_len = std::min(min_scan_key_len, static_cast<int>(end_key.size()));
}
int max_equal_index = -1;
for (int i = 0; i < read_params.start_key.size(); ++i) {
int j = 0;
for (; j < min_scan_key_len; ++j) {
if (read_params.start_key[i].get_value(j) != read_params.end_key[i].get_value(j)) {
break;
}
}
if (max_equal_index < j - 1) {
max_equal_index = j - 1;
}
}
for (int i = 0; i < max_equal_index; ++i) {
load_bf_columns->erase(i);
}
// remove the max_equal_index column when it's not varchar
// or longer than number of short key fields
if (max_equal_index == -1) {
return;
}
FieldType type = _tablet->tablet_schema().column(max_equal_index).type();
if ((type != OLAP_FIELD_TYPE_VARCHAR && type != OLAP_FIELD_TYPE_STRING)|| max_equal_index + 1 > _tablet->num_short_key_columns()) {
load_bf_columns->erase(max_equal_index);
}
}
OLAPStatus Reader::_init_delete_condition(const ReaderParams& read_params) {
if (read_params.reader_type == READER_CUMULATIVE_COMPACTION) {
return OLAP_SUCCESS;
}
_tablet->obtain_header_rdlock();
OLAPStatus ret = _delete_handler.init(_tablet->tablet_schema(), _tablet->delete_predicates(),
read_params.version.second, this);
_tablet->release_header_lock();
if (read_params.reader_type == READER_BASE_COMPACTION) {
_filter_delete = true;
}
return ret;
}
} // namespace doris
| 46.304046 | 135 | 0.521684 | spaces-X |
b4059cf3bbff0376086ece948f66bdf87f3b2a6e | 5,542 | hpp | C++ | DFNs/StereoReconstruction/ScanlineOptimization.hpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | 7 | 2019-02-26T15:09:50.000Z | 2021-09-30T07:39:01.000Z | DFNs/StereoReconstruction/ScanlineOptimization.hpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | null | null | null | DFNs/StereoReconstruction/ScanlineOptimization.hpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | 1 | 2020-12-06T12:09:05.000Z | 2020-12-06T12:09:05.000Z | /**
* @author Alessandro Bianco
*/
/**
* @addtogroup DFNs
* @{
*/
#ifndef STEREORECONSTRUCTION_SCANLINEOPTIMIZATION_HPP
#define STEREORECONSTRUCTION_SCANLINEOPTIMIZATION_HPP
#include "StereoReconstructionInterface.hpp"
#include <Types/CPP/PointCloud.hpp>
#include <Types/CPP/Frame.hpp>
#include <Helpers/ParametersListHelper.hpp>
#include <opencv2/core/core.hpp>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
namespace CDFF
{
namespace DFN
{
namespace StereoReconstruction
{
/**
* Scene reconstruction (as a 3D pointcloud) from 2D stereo images, using
* the Adaptive-Cost 2-Pass Scanline Optimization disparity mapping
* algorithm (by Tombari).
*
* Processing steps: (i) conversion of the images to PCL representation,
* (ii) computation of a disparity map using Tombari's algorithm, (iii)
* scene reconstruction based on the disparity map using a reprojection
* algorithm, (iv) downsampling of the generated pointcloud.
*
* @param costAggregationRadius
* @param spatialBandwidth
* @param colorBandwidth
* @param weakSmoothnessPenalty
* @param strongSmoothnessPenalty
*
* @param matchingOptionsSet.numberOfDisparities
* number of detected disparity intervals
* @param matchingOptionsSet.horizontalOffset
* @param matchingOptionsSet.ratioFilter
* @param matchingOptionsSet.peakFilter
* @param matchingOptionsSet.usePreprocessing
* @param matchingOptionsSet.useLeftRightConsistencyCheck
* @param matchingOptionsSet.leftRightConsistencyThreshold
*
* @param pointCloudSamplingDensity
* downsampling ratio: a number between 0 and 1 that describes how
* much downsampling of the generated pointcloud is desired. The
* pointcloud is subsampled at positions that are multiples of n,
* where n = 1/pointCloudSamplingDensity.
*
* @param stereoCameraParameters
* camera parameters in the form of the focal length and principal
* point of the left camera and the distance between the two cameras:
* the parameters to use to provide this information are called
* LeftFocalLength, LeftPrinciplePointX, LeftPrinciplePointY, and
* Baseline, respectively
*
* @param reconstructionSpace
* a bounding box for the reconstructed scene, provided via
* parameters called LimitX, LimitY, LimitZ. A reconstructed point
* of coordinates (x,y,z) is accepted into the pointcloud if
* -LimitX <= x <= LimitX, -LimitY <= y <= LimitY, 0 < z <= LimitZ.
*
* @reference The algorithm is adapted from Liang Wang, Miao Liao, Minglun
* Gong, Ruigang Yang, and David Nister (2006), "High Quality
* Real-Time Stereo using Adaptive Cost Aggregation and Dynamic
* Programming", Third IEEE International Symposium on 3D Data
* Processing, Visualization, and Transmission, 798-805.
*/
class ScanlineOptimization : public StereoReconstructionInterface
{
public:
ScanlineOptimization();
virtual ~ScanlineOptimization();
virtual void configure() override;
virtual void process() override;
private:
static const float EPSILON;
//DFN Parameters
typedef pcl::PointCloud<pcl::RGB> PclImage;
typedef pcl::PointCloud<pcl::RGB>::Ptr PclImagePtr;
typedef pcl::PointCloud<pcl::RGB>::ConstPtr PclImageConstPtr;
typedef pcl::PointCloud<pcl::PointXYZ> PclPointCloud;
typedef pcl::PointCloud<pcl::PointXYZ>::Ptr PclPointCloudPtr;
typedef pcl::PointCloud<pcl::PointXYZ>::ConstPtr PclPointCloudConstPtr;
struct ReconstructionSpace
{
float limitX;
float limitY;
float limitZ;
};
struct CameraParameters
{
float leftPrinciplePointX;
float leftPrinciplePointY;
float leftFocalLength;
float baseline;
};
struct MatchingOptionsSet
{
int numberOfDisparities;
int horizontalOffset;
int ratioFilter;
int peakFilter;
bool usePreprocessing;
bool useLeftRightConsistencyCheck;
int leftRightConsistencyThreshold;
};
struct ScanlineOptimizationOptionsSet
{
int costAggregationRadius;
int spatialBandwidth;
int colorBandwidth;
int strongSmoothnessPenalty;
int weakSmoothnessPenalty;
float pointCloudSamplingDensity;
float voxelGridLeafSize;
MatchingOptionsSet matchingOptionsSet;
CameraParameters cameraParameters;
ReconstructionSpace reconstructionSpace;
};
Helpers::ParametersListHelper parametersHelper;
ScanlineOptimizationOptionsSet parameters;
static const ScanlineOptimizationOptionsSet DEFAULT_PARAMETERS;
//Type conversion methods
PclImagePtr Convert(FrameWrapper::FrameConstPtr frame);
PointCloudWrapper::PointCloudConstPtr SampleCloud(PclPointCloudConstPtr pointCloud);
PointCloudWrapper::PointCloudConstPtr SampleCloudWithPeriodicSampling(PclPointCloudConstPtr pointCloud);
PointCloudWrapper::PointCloudConstPtr SampleCloudWithVoxelGrid(PclPointCloudConstPtr pointCloud);
cv::Mat PclImageToCvMatrix(PclImagePtr pclImage);
//Core computation methods
PclPointCloudPtr ComputePointCloud(PclImagePtr leftImage, PclImagePtr rightImage);
//Input Validation methods
void ValidateParameters();
//Testing methods for visualizing intermediate disparity map output.
#ifdef TESTING
#define SAVE_DISPARITY_MATRIX(visualMap) disparityMatrix = PclImageToCvMatrix(visualMap);
#else
#define SAVE_DISPARITY_MATRIX(visualMap)
#endif
};
}
}
}
#endif // STEREORECONSTRUCTION_SCANLINEOPTIMIZATION_HPP
/** @} */
| 32.034682 | 107 | 0.746481 | H2020-InFuse |
b4063a6084a2e2804dc5a3f28c50332ac508920c | 1,229 | cpp | C++ | QmlStream/AvLib/Common/AvCommon.cpp | milclo39/QtTools | 41463299799fc74d2691939e85b52c02a30ad9e6 | [
"Apache-2.0"
] | null | null | null | QmlStream/AvLib/Common/AvCommon.cpp | milclo39/QtTools | 41463299799fc74d2691939e85b52c02a30ad9e6 | [
"Apache-2.0"
] | null | null | null | QmlStream/AvLib/Common/AvCommon.cpp | milclo39/QtTools | 41463299799fc74d2691939e85b52c02a30ad9e6 | [
"Apache-2.0"
] | null | null | null | //--------------------------------------------------------------------------------//
/*!
@file AvCommon.cpp
@brief libAvライブラリ共通クラス
@author 大橋
*/
//--------------------------------------------------------------------------------//
#include "../AvCommon.h"
#define __STDC_CONSTANT_MACROS
#ifdef _STDINT_H
#undef _STDINT_H
#endif
extern "C"{
#include <libavcodec/avcodec.h>
}
//--------------------------------------------------------------------------------//
/*!
@brief コンストラクタ
*/
//--------------------------------------------------------------------------------//
ClAvImage::ClAvImage()
{
m_dDuration = 0;
}
//--------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------//
/*!
@brief コンストラクタ
@param[in] pFrame : フレームデータ
@param[in] dDuration : 画像表示時間(msec)
*/
//--------------------------------------------------------------------------------//
ClAvImage::ClAvImage(AVFrame *pFrame, qreal dDuration)
{
m_img = QImage(pFrame->data[0], pFrame->width, pFrame->height, QImage::Format_RGB888).copy();
m_dDuration = dDuration;
}
//--------------------------------------------------------------------------------//
| 28.581395 | 94 | 0.313263 | milclo39 |
b40aa8ff2d0280f6a0f3c399759b76a8e06f84e2 | 460 | hpp | C++ | MainBrain/test/ModelTest/ButtonTest/ButtonTest.hpp | smit-happens/YCP_EVOS | cecfa8aaa3c73945106786c44aa78d4fe872e3c3 | [
"MIT"
] | 10 | 2017-07-30T21:26:32.000Z | 2021-05-04T14:33:29.000Z | MainBrain/test/ModelTest/ButtonTest/ButtonTest.hpp | smit-happens/YCP_EVOS | cecfa8aaa3c73945106786c44aa78d4fe872e3c3 | [
"MIT"
] | 122 | 2017-07-30T15:55:55.000Z | 2019-05-19T20:29:13.000Z | MainBrain/test/ModelTest/ButtonTest/ButtonTest.hpp | smit-happens/YCP_EVOS | cecfa8aaa3c73945106786c44aa78d4fe872e3c3 | [
"MIT"
] | 3 | 2018-03-10T20:01:10.000Z | 2019-06-07T18:02:38.000Z | /** A one line description of the class.
*
* #include "ButtonTest.hpp"
* Created 3-12-18 By: Smitty
*
* A longer description.
*/
#ifndef BUTTONTEST_HPP
#define BUTTONTEST_HPP
#include "../BaseModelTest/BaseModelTest.hpp"
class ButtonTest : public BaseModelTest
{
public:
ButtonTest(void);
~ButtonTest(void);
void update(void);
String getName(void);
int getState(void);
void setState(void);
};
#endif //BUTTONTEST_HPP
| 14.375 | 45 | 0.678261 | smit-happens |
b40ce6f2a657d35e764164dc09ccee362752e54d | 1,263 | hpp | C++ | sim_algorithm/b_tree.hpp | pachicobue/CacheObliviousAlgorithms | db6e5f19c708d83208206091ae44cd6d7c71c4e0 | [
"Unlicense"
] | null | null | null | sim_algorithm/b_tree.hpp | pachicobue/CacheObliviousAlgorithms | db6e5f19c708d83208206091ae44cd6d7c71c4e0 | [
"Unlicense"
] | null | null | null | sim_algorithm/b_tree.hpp | pachicobue/CacheObliviousAlgorithms | db6e5f19c708d83208206091ae44cd6d7c71c4e0 | [
"Unlicense"
] | null | null | null | #pragma once
/**
* @file b_tree.hpp
* @brief B-木
*/
#include <memory>
#include "config.hpp"
#include "simulator/disk_variable.hpp"
/**
* @brief B-木
* @details Cache Awareなデータ構造
* @note
* 中間ノードは以下のデータを持つ (根のキー数はK-1未満でもOK ＋ 葉のsonsは空)
* - keys：k個のキー (キー数kは K-1 <= k <= 2K-1)
* - sons：k+1個の子ノード
*
* さらに探索木としての性質として以下が成立している
* - keysは昇順
* - sons[i]に含まれるキーは、keys[i-1]以上＆keys[i]未満
*/
class b_tree
{
struct node_t
{
node_t() = default;
std::vector<disk_var<data_t>> keys{};
std::vector<disk_var<std::shared_ptr<node_t>>> sons{};
disk_var<bool> leaf{false};
};
public:
/**
* @brief コンストラクタ
* @param K[in] キー数に関する定数
*/
b_tree(const std::size_t K_);
/**
* @brief コンストラクタ
* @param K[in] キー数に関する定数
* @param datas[in] 初期データ
*/
b_tree(const std::vector<data_t>& datas, const std::size_t K_);
/**
* @brief 挿入
* @param key[in] キー
*/
void insert(const data_t key);
/**
* @brief LowerBound
* @param key[in] キー
*/
data_t lower_bound(const data_t key) const;
using node_t = node_t;
using ptr_t = std::shared_ptr<node_t>;
std::size_t K;
private:
void illegal_insert(const data_t key);
ptr_t m_root;
};
| 19.136364 | 67 | 0.585115 | pachicobue |
b40dcafc5aed4211d2d4a3cd395cb8b1b74a10b6 | 2,057 | cpp | C++ | modules/segmentation/src/segmenter_organized_connected_component.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | 2 | 2021-02-22T11:36:33.000Z | 2021-07-20T11:31:08.000Z | modules/segmentation/src/segmenter_organized_connected_component.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | null | null | null | modules/segmentation/src/segmenter_organized_connected_component.cpp | v4r-tuwien/v4r | ff3fbd6d2b298b83268ba4737868bab258262a40 | [
"BSD-1-Clause",
"BSD-2-Clause"
] | 3 | 2018-10-19T10:39:23.000Z | 2021-04-07T13:39:03.000Z | #include <v4r/segmentation/plane_utils.h>
#include <v4r/segmentation/segmenter_organized_connected_component.h>
#include <pcl/common/angles.h>
#include <pcl/pcl_config.h>
#include <pcl/segmentation/euclidean_cluster_comparator.h>
#include <pcl/segmentation/organized_connected_component_segmentation.h>
#include <pcl/impl/instantiate.hpp>
namespace v4r {
template <typename PointT>
void OrganizedConnectedComponentSegmenter<PointT>::segment() {
clusters_.clear();
pcl::PointCloud<pcl::Label>::Ptr labels(new pcl::PointCloud<pcl::Label>);
labels->points.resize(scene_->points.size());
for (pcl::Label &p : labels->points)
p.label = 1;
#if PCL_VERSION_COMPARE(<=, 1, 8, 1)
auto euclidean_cluster_comp = boost::make_shared<pcl::EuclideanClusterComparator<PointT, pcl::Normal, pcl::Label>>();
euclidean_cluster_comp->setAngularThreshold(pcl::deg2rad(param_.angular_threshold_deg_));
std::vector<bool> exclude_labels(scene_->points.size(), false);
euclidean_cluster_comp->setExcludeLabels(exclude_labels);
#else
auto euclidean_cluster_comp = boost::make_shared<pcl::EuclideanClusterComparator<PointT, pcl::Label>>();
#endif
euclidean_cluster_comp->setInputCloud(scene_);
euclidean_cluster_comp->setLabels(labels);
euclidean_cluster_comp->setDistanceThreshold(param_.distance_threshold_, true);
pcl::PointCloud<pcl::Label> euclidean_labels;
std::vector<pcl::PointIndices> euclidean_label_indices;
pcl::OrganizedConnectedComponentSegmentation<PointT, pcl::Label> seg(euclidean_cluster_comp);
seg.setInputCloud(scene_);
seg.segment(euclidean_labels, euclidean_label_indices);
for (size_t i = 0; i < euclidean_label_indices.size(); i++) {
if (euclidean_label_indices[i].indices.size() >= param_.min_cluster_size_)
clusters_.push_back(euclidean_label_indices[i].indices);
}
}
#define PCL_INSTANTIATE_OrganizedConnectedComponentSegmenter(T) \
template class V4R_EXPORTS OrganizedConnectedComponentSegmenter<T>;
PCL_INSTANTIATE(OrganizedConnectedComponentSegmenter, PCL_XYZ_POINT_TYPES)
} // namespace v4r
| 41.979592 | 119 | 0.792902 | v4r-tuwien |
b40e7f9938f691f32bb44b53e04392a9a9ef413f | 6,967 | cpp | C++ | samples/game/Engine.cpp | Admer456/FoxGLBox | 6717902d102c929e565b3237753d4f918cf83ab7 | [
"MIT"
] | null | null | null | samples/game/Engine.cpp | Admer456/FoxGLBox | 6717902d102c929e565b3237753d4f918cf83ab7 | [
"MIT"
] | null | null | null | samples/game/Engine.cpp | Admer456/FoxGLBox | 6717902d102c929e565b3237753d4f918cf83ab7 | [
"MIT"
] | null | null | null | #include "IEngine.hpp"
#include "Vector.hpp"
#include "IRenderWorld.hpp"
#include "GameEntity.hpp"
#include <iostream>
#include <chrono>
#include "SDL.h"
#include "SDL_opengl.h"
#include "glm/gtc/matrix_transform.hpp"
#include "Engine.hpp"
namespace chrono = std::chrono;
IEngine* IEngine::AllocateInstance()
{
return new Engine();
}
void Engine::Init( const char* title, int width, int height )
{
gEngine = this;
// Init SDL and create a window
SDL_Init( SDL_INIT_VIDEO | SDL_INIT_EVENTS );
// Set the OpenGL context version
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 5 );
// Create the window and context
window = SDL_CreateWindow( title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL );
SDL_GLContext glContext = SDL_GL_CreateContext( window );
// Initialise the render system with render init params
renderSystem = foxglbox::GetRenderSystem();
RenderInitParams rip {
width, height, // Resolution
RenderInitParams::Renderer_OpenGL45,// OpenGL 4.5 render backend
RenderInitParams::Windowing_SDL2, // SDL2 windowing
glContext // OpenGL 4.5 context
};
renderWorld = renderSystem->InitRenderer( rip );
windowWidth = width;
windowHeight = height;
// Turning on VSync here so my GPU (and yours) doesn't crash'n'burn
SDL_GL_SetSwapInterval( 0 );
// Set relative mouse mode
SDL_SetRelativeMouseMode( SDL_TRUE );
// Populate the world with entities
CreateGameEntities();
}
bool Engine::RunFrame()
{
auto startPoint = chrono::system_clock::now();
{
SDL_Event event;
while ( SDL_PollEvent( &event ) )
{
if ( event.type == SDL_QUIT )
{
return false;
}
if ( event.type == SDL_KEYDOWN )
{
if ( event.key.keysym.sym == SDLK_ESCAPE )
{
return false;
}
}
}
// Update all updateable entities
for ( auto& ent : gameEntities )
{
if ( nullptr != ent )
{
if ( ent->entityFlags.canThink )
{
ent->Update( frameTime );
}
}
}
// Present the entities to the user (i.e. just update render entities)
for ( auto& ent : gameEntities )
{
if ( nullptr != ent )
{
if ( ent->entityFlags.visible )
{
ent->Present();
}
}
}
// Render the frame!
renderWorld->RenderFrame( mainView );
SDL_GL_SwapWindow( window );
}
auto endPoint = chrono::system_clock::now();
auto microSeconds = chrono::duration_cast<chrono::microseconds>(endPoint - startPoint);
frameTime = (microSeconds.count() / (1000.0f * 1000.0f)) * timeScale;
float frameRate = 1.0f / frameTime;
printf( "## Frame time: %3.2f ms\n## Frame rate: %4.1f fps\n\n", (frameTime * 1000.0f), frameRate );
return true;
}
void Engine::Shutdown()
{
for ( auto& ent : gameEntities )
{
if ( nullptr != ent )
{
delete ent;
ent = nullptr;
}
}
if ( nullptr != renderWorld )
{
renderWorld->Shutdown();
delete renderWorld;
renderWorld = nullptr;
}
}
void Engine::Print( const char* string )
{
std::cout << string;
}
RenderModelHandle Engine::GetModel( const char* modelPath )
{
if ( nullptr == modelPath )
{
return RenderHandleInvalid;
}
RenderModelParams modelParams{ modelPath };
return renderWorld->CreateModel( modelParams );
}
void Engine::SubmitRenderView( const RenderView& view, bool isMain )
{
if ( isMain )
{
mainView = view;
return;
}
}
void Engine::CreateGameEntities()
{
using namespace Entities;
for ( auto& ent : gameEntities )
{
ent = nullptr;
}
RenderModelHandle terrainHandle = GetModel( "terrain.obj" );
RenderModelHandle amanHandle = GetModel( "aman.obj" ); // The A-Man
RenderModelHandle testCoverHandle = GetModel( "test_cover.obj" );
RenderModelHandle testRockHandle = GetModel( "testrock.obj" );
// Ideally, you'd wanna load some sorta level/scene file, but I decided to keep the sample very simple
CreateEntity<Prop>( fglVector::Zero, fglVector( 90.0f, 0.0f, 0.0f ), terrainHandle );
CreateEntity<Prop>( fglVector( 2.0f, 1.0f, 6.0f ), fglVector( 90.0f, 0.0f, 0.0f ), testCoverHandle );
CreateEntity<Prop>( fglVector( 2.0f, 1.0f, 2.3f ), fglVector( 90.0f, 0.0f, 0.0f ), testRockHandle );
CreateEntity<PropRotating>( fglVector( 2.0f, 0.0f, 3.0f ), fglVector::Zero, amanHandle );
CreateEntity<PropInstanced>( fglVector( 4.0f, -2.0f, 5.0f ), fglVector::Zero, testRockHandle );
CreateEntity<Player>( fglVector( -8.0f, 0.0f, 0.0f ), fglVector::Zero, 0 );
for ( auto& ent : gameEntities )
{
if ( nullptr != ent )
{
ent->Spawn();
}
}
}
template<typename EntityClass>
EntityClass* Engine::CreateEntity( fglVector position, fglVector angles, RenderModelHandle modelHandle )
{
for ( auto& ent : gameEntities )
{
if ( nullptr == ent )
{
EntityClass* entity = Entities::GameEntity::Instance<EntityClass>( position, angles, modelHandle );
ent = entity;
return entity;
}
}
return nullptr;
}
/*
Copyright (c) 2021 Admer456
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.
*/
| 31.102679 | 119 | 0.602268 | Admer456 |
b41a3eaba77ff98259b271b1b784bc4b6fe6749c | 2,479 | cpp | C++ | ql/instruments/dividendbarrieroption.cpp | jiangjiali/QuantLib | 37c98eccfa18a95acb1e98b276831641be92b38e | [
"BSD-3-Clause"
] | 3,358 | 2015-12-18T02:56:17.000Z | 2022-03-31T02:42:47.000Z | ql/instruments/dividendbarrieroption.cpp | jiangjiali/QuantLib | 37c98eccfa18a95acb1e98b276831641be92b38e | [
"BSD-3-Clause"
] | 965 | 2015-12-21T10:35:28.000Z | 2022-03-30T02:47:00.000Z | ql/instruments/dividendbarrieroption.cpp | jiangjiali/QuantLib | 37c98eccfa18a95acb1e98b276831641be92b38e | [
"BSD-3-Clause"
] | 1,663 | 2015-12-17T17:45:38.000Z | 2022-03-31T07:58:29.000Z | /* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2008 Andreas Gaida
Copyright (C) 2008 Ralph Schreyer
Copyright (C) 2008 Klaus Spanderen
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<[email protected]>. The license is also available online at
<http://quantlib.org/license.shtml>.
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 license for more details.
*/
#include <ql/instruments/dividendbarrieroption.hpp>
#include <ql/utilities/dataformatters.hpp>
#include <ql/exercise.hpp>
namespace QuantLib {
DividendBarrierOption::DividendBarrierOption(
Barrier::Type barrierType,
Real barrier,
Real rebate,
const ext::shared_ptr<StrikedTypePayoff>& payoff,
const ext::shared_ptr<Exercise>& exercise,
const std::vector<Date>& dividendDates,
const std::vector<Real>& dividends)
: BarrierOption(barrierType, barrier, rebate, payoff, exercise),
cashFlow_(DividendVector(dividendDates, dividends)) {}
void DividendBarrierOption::setupArguments(
PricingEngine::arguments* args) const {
BarrierOption::setupArguments(args);
auto* arguments = dynamic_cast<DividendBarrierOption::arguments*>(args);
QL_REQUIRE(arguments != nullptr, "wrong engine type");
arguments->cashFlow = cashFlow_;
}
void DividendBarrierOption::arguments::validate() const {
BarrierOption::arguments::validate();
Date exerciseDate = exercise->lastDate();
for (Size i = 0; i < cashFlow.size(); i++) {
QL_REQUIRE(cashFlow[i]->date() <= exerciseDate,
"the " << io::ordinal(i+1) << " dividend date ("
<< cashFlow[i]->date()
<< ") is later than the exercise date ("
<< exerciseDate << ")");
}
}
}
| 37 | 80 | 0.628479 | jiangjiali |
b4232b8a0751bd384cf1aa00e9995636b242165c | 3,084 | cpp | C++ | Source/CPP_Tutorial/CPP_TutorialGameMode.cpp | Mordil/UE4-CPP-Tutorial | 0ad3a50c0ef71949db25c67010738486e49c32fc | [
"MIT"
] | null | null | null | Source/CPP_Tutorial/CPP_TutorialGameMode.cpp | Mordil/UE4-CPP-Tutorial | 0ad3a50c0ef71949db25c67010738486e49c32fc | [
"MIT"
] | null | null | null | Source/CPP_Tutorial/CPP_TutorialGameMode.cpp | Mordil/UE4-CPP-Tutorial | 0ad3a50c0ef71949db25c67010738486e49c32fc | [
"MIT"
] | null | null | null | // Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
#include "CPP_Tutorial.h"
#include "Kismet/GameplayStatics.h"
#include "Blueprint/UserWidget.h"
#include "CPP_TutorialGameMode.h"
#include "CPP_TutorialCharacter.h"
#include "SpawnVolume.h"
ACPP_TutorialGameMode::ACPP_TutorialGameMode()
{
// set default pawn class to our Blueprinted character
static ConstructorHelpers::FClassFinder<APawn> PlayerPawnBPClass(TEXT("/Game/ThirdPersonCPP/Blueprints/ThirdPersonCharacter"));
if (PlayerPawnBPClass.Class != NULL)
{
DefaultPawnClass = PlayerPawnBPClass.Class;
}
DecayRate = .01f;
}
void ACPP_TutorialGameMode::BeginPlay()
{
Super::BeginPlay();
// find all spawn volume Actors
TArray<AActor*> foundActors;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASpawnVolume::StaticClass(), foundActors);
for (auto actor : foundActors)
{
ASpawnVolume* spawnVolumeActor = Cast<ASpawnVolume>(actor);
if (spawnVolumeActor)
{
_spawnVolumeActors.AddUnique(spawnVolumeActor);
}
}
SetCurrentState(BatteryPlayState::Playing);
// set the score to beat
ACPP_TutorialCharacter* MyCharacter = Cast<ACPP_TutorialCharacter>(UGameplayStatics::GetPlayerPawn(this, 0));
if (MyCharacter)
{
PowerToWin = (MyCharacter->GetInitialPower()) * 1.25f;
}
if (HUDWidgetClass != nullptr)
{
CurrentWidget = CreateWidget<UUserWidget>(GetWorld(), HUDWidgetClass);
if (CurrentWidget != nullptr)
{
CurrentWidget->AddToViewport();
}
}
}
void ACPP_TutorialGameMode::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
ACPP_TutorialCharacter* MyCharacter = Cast<ACPP_TutorialCharacter>(UGameplayStatics::GetPlayerPawn(this, 0));
if (MyCharacter)
{
if (MyCharacter->GetCurrentPower() > PowerToWin)
{
SetCurrentState(BatteryPlayState::Won);
}
else if (MyCharacter->GetCurrentPower() > 0)
{
MyCharacter->UpdatePower(-DeltaTime * DecayRate * (MyCharacter->GetInitialPower()));
}
else
{
SetCurrentState(BatteryPlayState::GameOver);
}
}
}
void ACPP_TutorialGameMode::SetCurrentState(BatteryPlayState newState)
{
_currentState = newState;
_handleNewState(_currentState);
}
void ACPP_TutorialGameMode::_handleNewState(BatteryPlayState newState)
{
auto setVolumesActiveState = [&](bool valueToSet)
{
for (auto volume : _spawnVolumeActors)
{
volume->SetSpawningActive(valueToSet);
}
};
switch (newState)
{
case BatteryPlayState::Playing:
{
setVolumesActiveState(true);
break;
}
case BatteryPlayState::Won:
{
setVolumesActiveState(false);
break;
}
case BatteryPlayState::GameOver:
{
setVolumesActiveState(false);
APlayerController* PlayerController = UGameplayStatics::GetPlayerController(this, 0);
if (PlayerController)
{
PlayerController->SetCinematicMode(true, false, false, true, true);
}
ACharacter* MyCharacter = UGameplayStatics::GetPlayerCharacter(this, 0);
if (MyCharacter)
{
MyCharacter->GetMesh()->SetSimulatePhysics(true);
MyCharacter->GetMovementComponent()->MovementState.bCanJump = false;
}
break;
}
case BatteryPlayState::Unknown:
default:
break;
}
}
| 22.510949 | 128 | 0.74773 | Mordil |
b4242721bfa66823bdf0269a54f9be88bb901581 | 1,873 | cpp | C++ | dlib/dlib/matlab/example_mex_class.cpp | mohitjain4395/mosip | 20ee978dc539be42c8b79cd4b604fdf681e7b672 | [
"MIT"
] | 11,719 | 2015-01-03T22:38:57.000Z | 2022-03-30T21:45:04.000Z | dlib/matlab/example_mex_class.cpp | KiLJ4EdeN/dlib | eb1f08ce6ab3ca6f9d10425d899103de3c0df56c | [
"BSL-1.0"
] | 2,518 | 2015-01-04T04:38:06.000Z | 2022-03-31T11:55:43.000Z | dlib/matlab/example_mex_class.cpp | KiLJ4EdeN/dlib | eb1f08ce6ab3ca6f9d10425d899103de3c0df56c | [
"BSL-1.0"
] | 3,308 | 2015-01-01T14:34:16.000Z | 2022-03-31T07:20:07.000Z | // The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*
This mex file will create a MATLAB function called example_mex_class. If you call it
with no arguments it will output the MATLAB .m code to create a MATLAB wrapper class.
Paste that code into a .m file. Then you will be able to work with this C++ class
directly in MATLAB.
*/
#include <iostream>
#include <dlib/matrix.h>
using namespace std;
using namespace dlib;
class example_class
{
public:
// The class must have a default constructor. It's also the only kind of constructor
// you can call from MATLAB.
example_class()
{
xx.set_size(3,2);
xx = 1;
}
// The rest of the member functions that you want to bind have to return void and
// generally have the same syntax limitations as regular mex funcitons.
void do_stuff(const matrix_colmajor& x)
{
cout << "in do_stuff" << endl;
cout << x << endl;
xx = x;
}
void do_other_stuff(int x)
{
cout << "in do_other_stuff" << endl;
cout << "x: " << x << endl;
}
void print_state()
{
cout << xx << endl;
}
// saveobj() and load_obj() are special functions. If you provide these then you will
// be able to save() and load() your objects using MATLAB's built in object
// serialization.
void saveobj(matrix_colmajor& state)
{
// save this object's state to state.
state = xx;
}
void load_obj(const matrix_colmajor& state)
{
xx = state;
}
private:
matrix_colmajor xx;
};
// Just tell the mex wrapper the name of your class and list the methods you want to bind.
#define MEX_CLASS_NAME example_class
#define MEX_CLASS_METHODS do_stuff, do_other_stuff, print_state, saveobj, load_obj
#include "mex_wrapper.cpp"
| 25.657534 | 91 | 0.651361 | mohitjain4395 |
b4280f4bc1f83b8a7a5fdc0606d2441e0ba995c1 | 2,321 | cpp | C++ | dev/Generated/ToggleSplitButton.properties.cpp | johnpf74/microsoft-ui-xaml | db7b371a8155a81800f4432d6052ef54cb20642a | [
"MIT"
] | 3 | 2018-12-06T08:02:41.000Z | 2020-03-24T13:23:27.000Z | dev/Generated/ToggleSplitButton.properties.cpp | jsuarezruiz/microsoft-ui-xaml | b6f8806e07206caebccc81fb77d325efa67d29de | [
"MIT"
] | 2 | 2018-12-07T16:49:26.000Z | 2018-12-07T16:50:00.000Z | dev/Generated/ToggleSplitButton.properties.cpp | jsuarezruiz/microsoft-ui-xaml | b6f8806e07206caebccc81fb77d325efa67d29de | [
"MIT"
] | 1 | 2020-08-28T10:29:11.000Z | 2020-08-28T10:29:11.000Z | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.
// DO NOT EDIT! This file was generated by CustomTasks.DependencyPropertyCodeGen
#include "pch.h"
#include "common.h"
#include "ToggleSplitButton.h"
CppWinRTActivatableClassWithDPFactory(ToggleSplitButton)
GlobalDependencyProperty ToggleSplitButtonProperties::s_IsCheckedProperty{ nullptr };
ToggleSplitButtonProperties::ToggleSplitButtonProperties()
: m_isCheckedChangedEventSource{static_cast<ToggleSplitButton*>(this)}
{
EnsureProperties();
}
void ToggleSplitButtonProperties::EnsureProperties()
{
SplitButton::EnsureProperties();
if (!s_IsCheckedProperty)
{
s_IsCheckedProperty =
InitializeDependencyProperty(
L"IsChecked",
winrt::name_of<bool>(),
winrt::name_of<winrt::ToggleSplitButton>(),
false /* isAttached */,
ValueHelper<bool>::BoxedDefaultValue(),
winrt::PropertyChangedCallback(&OnPropertyChanged));
}
}
void ToggleSplitButtonProperties::ClearProperties()
{
s_IsCheckedProperty = nullptr;
SplitButton::ClearProperties();
}
void ToggleSplitButtonProperties::OnPropertyChanged(
winrt::DependencyObject const& sender,
winrt::DependencyPropertyChangedEventArgs const& args)
{
auto owner = sender.as<winrt::ToggleSplitButton>();
winrt::get_self<ToggleSplitButton>(owner)->OnPropertyChanged(args);
}
void ToggleSplitButtonProperties::IsChecked(bool value)
{
static_cast<ToggleSplitButton*>(this)->SetValue(s_IsCheckedProperty, ValueHelper<bool>::BoxValueIfNecessary(value));
}
bool ToggleSplitButtonProperties::IsChecked()
{
return ValueHelper<bool>::CastOrUnbox(static_cast<ToggleSplitButton*>(this)->GetValue(s_IsCheckedProperty));
}
winrt::event_token ToggleSplitButtonProperties::IsCheckedChanged(winrt::TypedEventHandler<winrt::ToggleSplitButton, winrt::ToggleSplitButtonIsCheckedChangedEventArgs> const& value)
{
return m_isCheckedChangedEventSource.add(value);
}
void ToggleSplitButtonProperties::IsCheckedChanged(winrt::event_token const& token)
{
m_isCheckedChangedEventSource.remove(token);
}
| 34.132353 | 181 | 0.73589 | johnpf74 |
b42af0c603698dc93264550ad8a2840bcd4d7d90 | 11,229 | cpp | C++ | Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp | samsmu/MITK | c93dce6dc38d8f4c961de4440e4dd113b9841c8c | [
"BSD-3-Clause"
] | 5 | 2015-02-05T10:58:41.000Z | 2019-04-17T15:04:07.000Z | Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp | samsmu/MITK | c93dce6dc38d8f4c961de4440e4dd113b9841c8c | [
"BSD-3-Clause"
] | 141 | 2015-03-03T06:52:01.000Z | 2020-12-10T07:28:14.000Z | Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp | samsmu/MITK | c93dce6dc38d8f4c961de4440e4dd113b9841c8c | [
"BSD-3-Clause"
] | 4 | 2015-02-19T06:48:13.000Z | 2020-06-19T16:20:25.000Z | /*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVolumeMapperVtkSmart3D.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkTransferFunctionInitializer.h"
#include "mitkLevelWindowProperty.h"
#include <mitkImageVtkAccessor.h>
#include <vtkObjectFactory.h>
#include <vtkRenderingOpenGL2ObjectFactory.h>
#include <vtkRenderingVolumeOpenGL2ObjectFactory.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
void mitk::VolumeMapperVtkSmart3D::initialize()
{
mitk::Image *input = const_cast<mitk::Image *>(static_cast<const mitk::Image *>(this->GetDataNode()->GetData()));
int displayedComponent = 0;
this->GetDataNode()->GetIntProperty("Image.Displayed Component", displayedComponent);
int numberOfComponents = input->GetPixelType().GetNumberOfComponents();
int timeStep = 0;
this->GetDataNode()->GetIntProperty("Image.Displayed Timestep", timeStep);
int numberOfTimeSteps = input->GetTimeSteps();
if (!m_Volume->GetMapper() ||
(numberOfTimeSteps > 1 && timeStep != m_LastTimeStep) ||
(numberOfComponents > 1 && displayedComponent != m_LastComponent)) {
createMapper(GetInputImage());
createVolume();
createVolumeProperty();
}
}
void mitk::VolumeMapperVtkSmart3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
initialize();
bool value;
this->GetDataNode()->GetBoolProperty("volumerendering", value, renderer);
if (!value)
{
m_Volume->VisibilityOff();
return;
}
else
{
m_Volume->VisibilityOn();
}
UpdateTransferFunctions(renderer);
UpdateRenderMode(renderer);
this->Modified();
}
vtkProp* mitk::VolumeMapperVtkSmart3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
initialize();
return m_Volume;
}
void mitk::VolumeMapperVtkSmart3D::ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)
{
}
void mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
{
// GPU_INFO << "SetDefaultProperties";
node->AddProperty("volumerendering", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.usemip", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.cpu.ambient", mitk::FloatProperty::New(0.10f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
node->AddProperty("volumerendering.usegpu", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.useray", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.gpu.ambient", mitk::FloatProperty::New(0.25f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
node->AddProperty("binary", mitk::BoolProperty::New(false), renderer, overwrite);
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
if (image.IsNotNull() && image->IsInitialized())
{
if ((overwrite) || (node->GetProperty("levelwindow", renderer) == nullptr))
{
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
levelwindow.SetAuto(image);
levWinProp->SetLevelWindow(levelwindow);
node->SetProperty("levelwindow", levWinProp, renderer);
}
if ((overwrite) || (node->GetProperty("TransferFunction", renderer) == nullptr))
{
// add a default transfer function
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
tfInit->SetTransferFunctionMode(0);
node->SetProperty("TransferFunction", mitk::TransferFunctionProperty::New(tf.GetPointer()));
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
void mitk::VolumeMapperVtkSmart3D::setClippingPlanes(vtkPlanes* planes)
{
initialize();
m_SmartVolumeMapper->SetClippingPlanes(planes);
}
vtkImageData* mitk::VolumeMapperVtkSmart3D::GetInputImage()
{
mitk::Image *input = const_cast<mitk::Image *>(static_cast<const mitk::Image *>(this->GetDataNode()->GetData()));
mitk::ImageVtkAccessor accessor(input);
vtkImageData* img = accessor.getVtkImageData(this->GetTimestep());
m_LastTimeStep = this->GetTimestep();
if (input->GetPixelType().GetNumberOfComponents() > 1) {
int displayedComponent = 0;
this->GetDataNode()->GetIntProperty("Image.Displayed Component", displayedComponent);
m_VectorComponentExtractor->SetComponents(displayedComponent);
m_VectorComponentExtractor->SetInputData(img);
m_VectorComponentExtractor->Modified();
m_VectorComponentExtractor->Update();
img = m_VectorComponentExtractor->GetOutput();
m_LastComponent = displayedComponent;
}
if (img) {
img->SetSpacing(1,1,1);
}
return img;
}
void mitk::VolumeMapperVtkSmart3D::createMapper(vtkImageData* imageData)
{
m_SmartVolumeMapper = vtkSmartPointer<vtkSmartVolumeMapper>::New();
m_SmartVolumeMapper->SetBlendModeToComposite();
m_SmartVolumeMapper->SetInputData(imageData);
}
void mitk::VolumeMapperVtkSmart3D::createVolume()
{
m_Volume->VisibilityOff();
m_Volume->SetMapper(m_SmartVolumeMapper);
m_Volume->SetProperty(m_VolumeProperty);
}
void mitk::VolumeMapperVtkSmart3D::createVolumeProperty()
{
m_VolumeProperty->ShadeOn();
m_VolumeProperty->SetInterpolationType(VTK_LINEAR_INTERPOLATION);
}
void mitk::VolumeMapperVtkSmart3D::UpdateTransferFunctions(mitk::BaseRenderer *renderer)
{
vtkSmartPointer<vtkPiecewiseFunction> opacityTransferFunction;
vtkSmartPointer<vtkPiecewiseFunction> gradientTransferFunction;
vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction;
bool isBinary = false;
this->GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
if (isBinary)
{
colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
float rgb[3];
if (!GetDataNode()->GetColor(rgb, renderer))
rgb[0] = rgb[1] = rgb[2] = 1;
colorTransferFunction->AddRGBPoint(0, rgb[0], rgb[1], rgb[2]);
colorTransferFunction->Modified();
opacityTransferFunction = m_BinaryOpacityTransferFunction;
gradientTransferFunction = m_BinaryGradientTransferFunction;
}
else
{
mitk::TransferFunctionProperty *transferFunctionProp =
dynamic_cast<mitk::TransferFunctionProperty *>(this->GetDataNode()->GetProperty("TransferFunction", renderer));
if (transferFunctionProp)
{
opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
}
else
{
opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
gradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
}
}
m_VolumeProperty->SetColor(colorTransferFunction);
m_VolumeProperty->SetScalarOpacity(opacityTransferFunction);
m_VolumeProperty->SetGradientOpacity(gradientTransferFunction);
}
void mitk::VolumeMapperVtkSmart3D::UpdateRenderMode(mitk::BaseRenderer *renderer)
{
bool usegpu = false;
bool useray = false;
bool usemip = false;
this->GetDataNode()->GetBoolProperty("volumerendering.usegpu", usegpu);
this->GetDataNode()->GetBoolProperty("volumerendering.useray", useray);
this->GetDataNode()->GetBoolProperty("volumerendering.usemip", usemip);
if (usegpu)
m_SmartVolumeMapper->SetRequestedRenderModeToGPU();
else if (useray)
m_SmartVolumeMapper->SetRequestedRenderModeToRayCast();
else
m_SmartVolumeMapper->SetRequestedRenderModeToDefault();
int blendMode;
if (this->GetDataNode()->GetIntProperty("volumerendering.blendmode", blendMode))
m_SmartVolumeMapper->SetBlendMode(blendMode);
else if (usemip)
m_SmartVolumeMapper->SetBlendMode(vtkSmartVolumeMapper::MAXIMUM_INTENSITY_BLEND);
// shading parameter
if (m_SmartVolumeMapper->GetRequestedRenderMode() == vtkSmartVolumeMapper::GPURenderMode)
{
float value = 0;
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient", value, renderer))
m_VolumeProperty->SetAmbient(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse", value, renderer))
m_VolumeProperty->SetDiffuse(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular", value, renderer))
m_VolumeProperty->SetSpecular(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power", value, renderer))
m_VolumeProperty->SetSpecularPower(value);
}
else
{
float value = 0;
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient", value, renderer))
m_VolumeProperty->SetAmbient(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse", value, renderer))
m_VolumeProperty->SetDiffuse(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular", value, renderer))
m_VolumeProperty->SetSpecular(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power", value, renderer))
m_VolumeProperty->SetSpecularPower(value);
}
}
mitk::VolumeMapperVtkSmart3D::VolumeMapperVtkSmart3D() :
m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New()),
m_LastTimeStep(-1),
m_LastComponent(-1)
{
vtkObjectFactory::RegisterFactory(vtkRenderingOpenGL2ObjectFactory::New());
vtkObjectFactory::RegisterFactory(vtkRenderingVolumeOpenGL2ObjectFactory::New());
m_VolumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
m_Volume = vtkSmartPointer<vtkVolume>::New();
m_BinaryOpacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_BinaryOpacityTransferFunction->AddPoint(0, 0.0);
m_BinaryOpacityTransferFunction->AddPoint(1, 1.0);
m_BinaryGradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
m_BinaryGradientTransferFunction->AddPoint(0.0, 1.0);
}
mitk::VolumeMapperVtkSmart3D::~VolumeMapperVtkSmart3D()
{
}
| 37.059406 | 123 | 0.747618 | samsmu |
b4305e2c7fb22789d7587e77e7fe3c18933a591b | 1,088 | cpp | C++ | src/mt/fs/file.cpp | nfagan/mtype | a745271d366df64e1b4692cc90f0685ea4084ba6 | [
"MIT"
] | null | null | null | src/mt/fs/file.cpp | nfagan/mtype | a745271d366df64e1b4692cc90f0685ea4084ba6 | [
"MIT"
] | null | null | null | src/mt/fs/file.cpp | nfagan/mtype | a745271d366df64e1b4692cc90f0685ea4084ba6 | [
"MIT"
] | null | null | null | #include "file.hpp"
#include "path.hpp"
#include "../Optional.hpp"
#include "../config.hpp"
#include <fstream>
#if defined(MT_UNIX)
#include <sys/stat.h>
#endif
#if MT_IS_MSVC
#include <windows.h>
#endif
namespace mt::fs {
Optional<std::unique_ptr<std::string>> read_file(const FilePath& path) {
std::ifstream ifs(path.str());
if (!ifs) {
return NullOpt{};
}
auto contents = std::make_unique<std::string>((std::istreambuf_iterator<char>(ifs)),
(std::istreambuf_iterator<char>()));
return Optional<std::unique_ptr<std::string>>(std::move(contents));
}
#if defined(MT_UNIX)
bool file_exists(const FilePath& path) {
struct stat sb;
const int status = stat(path.c_str(), &sb);
if (status != 0) {
return false;
}
return (sb.st_mode & S_IFMT) == S_IFREG;
}
#elif defined(MT_WIN)
bool file_exists(const FilePath& path) {
return !(INVALID_FILE_ATTRIBUTES == GetFileAttributes(path.c_str()) &&
GetLastError() == ERROR_FILE_NOT_FOUND);
}
#else
#error "Expected one of Unix or Windows for OS."
#endif
}
| 22.666667 | 86 | 0.653493 | nfagan |
b4309cac4069973b4739419e4d2ff81cb2b2b07a | 1,855 | cpp | C++ | src/zimg/depth/x86/f16c_ivb.cpp | marxin/zimg | b6334acf4112877afc400cd9a0ace54e171e3f11 | [
"WTFPL"
] | 287 | 2015-01-02T13:59:32.000Z | 2022-03-29T22:47:54.000Z | src/zimg/depth/x86/f16c_ivb.cpp | marxin/zimg | b6334acf4112877afc400cd9a0ace54e171e3f11 | [
"WTFPL"
] | 143 | 2015-04-17T06:20:17.000Z | 2022-03-29T09:13:45.000Z | src/zimg/depth/x86/f16c_ivb.cpp | marxin/zimg | b6334acf4112877afc400cd9a0ace54e171e3f11 | [
"WTFPL"
] | 64 | 2015-01-02T13:59:35.000Z | 2022-03-30T17:20:55.000Z | #ifdef ZIMG_X86
#include "common/ccdep.h"
#include <immintrin.h>
#include "common/align.h"
#include "f16c_x86.h"
#include "common/x86/sse2_util.h"
#include "common/x86/avx_util.h"
namespace zimg {
namespace depth {
void f16c_half_to_float_ivb(const void *src, void *dst, unsigned left, unsigned right)
{
const uint16_t *src_p = static_cast<const uint16_t *>(src);
float *dst_p = static_cast<float *>(dst);
unsigned vec_left = ceil_n(left, 8);
unsigned vec_right = floor_n(right, 8);
if (left != vec_left) {
__m256 x = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)(src_p + vec_left - 8)));
mm256_store_idxhi_ps(dst_p + vec_left - 8, x, left % 8);
}
for (unsigned j = vec_left; j < vec_right; j += 8) {
__m256 x = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)(src_p + j)));
_mm256_store_ps(dst_p + j, x);
}
if (right != vec_right) {
__m256 x = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)(src_p + vec_right)));
mm256_store_idxlo_ps(dst_p + vec_right, x, right % 8);
}
}
void f16c_float_to_half_ivb(const void *src, void *dst, unsigned left, unsigned right)
{
const float *src_p = static_cast<const float *>(src);
uint16_t *dst_p = static_cast<uint16_t *>(dst);
unsigned vec_left = ceil_n(left, 8);
unsigned vec_right = floor_n(right, 8);
if (left != vec_left) {
__m128i x = _mm256_cvtps_ph(_mm256_load_ps(src_p + vec_left - 8), 0);
mm_store_idxhi_epi16((__m128i *)(dst_p + vec_left - 8), x, left % 8);
}
for (unsigned j = vec_left; j < vec_right; j += 8) {
__m128i x = _mm256_cvtps_ph(_mm256_load_ps(src_p + j), 0);
_mm_store_si128((__m128i *)(dst_p + j), x);
}
if (right != vec_right) {
__m128i x = _mm256_cvtps_ph(_mm256_load_ps(src_p + vec_right), 0);
mm_store_idxlo_epi16((__m128i *)(dst_p + vec_right), x, right % 8);
}
}
} // namespace depth
} // namespace zimg
#endif // ZIMG_X86
| 27.686567 | 86 | 0.690566 | marxin |
b4331f2c941c359559c6e89cd72977ca322af596 | 901 | hpp | C++ | src/stan/language/ast/node/array_expr.hpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 1 | 2019-09-06T15:53:17.000Z | 2019-09-06T15:53:17.000Z | src/stan/language/ast/node/array_expr.hpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 8 | 2019-01-17T18:51:16.000Z | 2019-01-17T18:51:39.000Z | src/stan/language/ast/node/array_expr.hpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | null | null | null | #ifndef STAN_LANG_AST_NODE_ARRAY_EXPR_HPP
#define STAN_LANG_AST_NODE_ARRAY_EXPR_HPP
#include "expression.hpp"
#include "stan/language/ast/scope.hpp"
#include "stan/language/ast/type/bare_expr_type.hpp"
#include <cstddef>
#include <vector>
namespace stan {
namespace lang {
struct expresssion;
/**
* Structure to hold an array expression.
*/
struct array_expr {
/**
* Sequence of expressions for array values.
*/
std::vector<expression> args_;
/**
* Type of array.
*/
bare_expr_type type_;
/**
* True if there is a variable within any of the expressions
* that is a parameter, transformed parameter, or non-integer
* local variable.
*/
bool has_var_;
/**
* Scope of this array expression.
*
*/
scope array_expr_scope_;
/**
* Construct a default array expression.
*/
array_expr();
};
} // namespace lang
} // namespace stan
#endif
| 17.666667 | 63 | 0.687014 | alashworth |
b4342462aa98b494a6652dd589c634e20f9b9b4d | 16,530 | cpp | C++ | libsrc/hyperion/Hyperion.cpp | juanesf/hyperion_openwrt_mt7620 | a29624e1ca03c37517b043956b55064b6021c7b4 | [
"MIT"
] | null | null | null | libsrc/hyperion/Hyperion.cpp | juanesf/hyperion_openwrt_mt7620 | a29624e1ca03c37517b043956b55064b6021c7b4 | [
"MIT"
] | null | null | null | libsrc/hyperion/Hyperion.cpp | juanesf/hyperion_openwrt_mt7620 | a29624e1ca03c37517b043956b55064b6021c7b4 | [
"MIT"
] | null | null | null | #include <cassert>
#include "HyperionConfig.h"
#include "Poco/RegularExpression.h"
#include "Poco/StringTokenizer.h"
#include "Poco/Timestamp.h"
#include "Poco/Delegate.h"
#include "Poco/NumberParser.h"
#include "hyperion/Hyperion.h"
#include "hyperion/ImageProcessorFactory.h"
#include "leddevice/LedDevice.h"
#include "leddevice/LedDeviceFactory.h"
#include "MultiColorTransform.h"
#include "LinearColorSmoothing.h"
// effect engine includes
#ifdef ENABLE_EFFECT_ENGINE
#include "effectengine/EffectEngine.h"
#endif
ColorOrder Hyperion::createColorOrder(const Poco::DynamicStruct &deviceConfig) {
std::string order = deviceConfig["colorOrder"];
if (order == "rgb") {
return ORDER_RGB;
}
else if (order == "bgr") {
return ORDER_BGR;
}
else if (order == "rbg") {
return ORDER_RBG;
}
else if (order == "brg") {
return ORDER_BRG;
}
else if (order == "gbr") {
return ORDER_GBR;
}
else if (order == "grb") {
return ORDER_GRB;
}
else {
std::cout << "Unknown color order defined (" << order << "). Using RGB." << std::endl;
}
return ORDER_RGB;
}
ColorTransform *Hyperion::createColorTransform(const Poco::DynamicStruct &transformConfig) {
std::string id = "default";
id = transformConfig["id"].toString();
RgbChannelTransform *redTransform =
createRgbChannelTransform(transformConfig["red"].extract<Poco::DynamicStruct>());
RgbChannelTransform *greenTransform =
createRgbChannelTransform(transformConfig["green"].extract<Poco::DynamicStruct>());
RgbChannelTransform *blueTransform =
createRgbChannelTransform(transformConfig["blue"].extract<Poco::DynamicStruct>());
HsvTransform *hsvTransform = createHsvTransform(transformConfig["hsv"].extract<Poco::DynamicStruct>());
ColorTransform *transform = new ColorTransform();
transform->_id = id;
transform->_rgbRedTransform = *redTransform;
transform->_rgbGreenTransform = *greenTransform;
transform->_rgbBlueTransform = *blueTransform;
transform->_hsvTransform = *hsvTransform;
// Cleanup the allocated individual transforms
delete redTransform;
delete greenTransform;
delete blueTransform;
delete hsvTransform;
return transform;
}
MultiColorTransform *Hyperion::createLedColorsTransform(const unsigned ledCnt, const Poco::DynamicStruct &colorConfig) {
// Create the result, the transforms are added to this
MultiColorTransform *transform = new MultiColorTransform(ledCnt);
Poco::Dynamic::Var transformConfig = colorConfig["transform"];
if (!transformConfig.isArray()) {
ColorTransform *colorTransform = createColorTransform(transformConfig.extract<Poco::DynamicStruct>());
transform->addTransform(colorTransform);
transform->setTransformForLed(colorTransform->_id, 0, ledCnt - 1);
}
else {
const Poco::RegularExpression overallExp("([0-9]+(\\-[0-9]+)?)(,[ ]*([0-9]+(\\-[0-9]+)?))*");
for (unsigned i = 0; i < transformConfig.size(); i++) {
const Poco::DynamicStruct &config = transformConfig[i].extract<Poco::DynamicStruct>();
ColorTransform *colorTransform = createColorTransform(config);
transform->addTransform(colorTransform);
const std::string ledIndicesStr = config["leds"].toString();
if (ledIndicesStr.compare("*") == 0) {
// Special case for indices '*' => all leds
transform->setTransformForLed(colorTransform->_id, 0, ledCnt - 1);
std::cout << "ColorTransform '" << colorTransform->_id << "' => [0; " << ledCnt - 1 << "]" << std::endl;
continue;
}
if (!overallExp.match(ledIndicesStr)) {
std::cerr << "Given led indices " << i << " not correct format: " << ledIndicesStr << std::endl;
continue;
}
std::cout << "ColorTransform '" << colorTransform->_id << "' => [";
Poco::StringTokenizer ledIndexList(ledIndicesStr, ",", Poco::StringTokenizer::TOK_TRIM);
for (unsigned j = 0; j < ledIndexList.count(); ++j) {
if (j > 0) {
std::cout << ", ";
}
if (ledIndexList[j].find("-") != std::string::npos) {
Poco::StringTokenizer ledIndices(ledIndexList[j], "-", Poco::StringTokenizer::TOK_TRIM);
const unsigned startInd = Poco::NumberParser::parseUnsigned(ledIndices[0]);
const unsigned endInd = Poco::NumberParser::parseUnsigned(ledIndices[1]);
transform->setTransformForLed(colorTransform->_id, startInd, endInd);
std::cout << startInd << "-" << endInd;
}
else {
const unsigned index = Poco::NumberParser::parseUnsigned(ledIndexList[j]);
transform->setTransformForLed(colorTransform->_id, index, index);
std::cout << index;
}
}
std::cout << "]" << std::endl;
}
}
return transform;
}
HsvTransform *Hyperion::createHsvTransform(const Poco::DynamicStruct &hsvConfig) {
double saturationGain, valueGain;
saturationGain = hsvConfig["saturationGain"].convert<double>();
valueGain = hsvConfig["valueGain"].convert<double>();
return new HsvTransform(saturationGain, valueGain);
}
RgbChannelTransform *Hyperion::createRgbChannelTransform(const Poco::DynamicStruct &colorConfig) {
double threshold, gamma, blacklevel, whitelevel;
threshold = colorConfig["threshold"].convert<double>();
gamma = colorConfig["gamma"].convert<double>();
blacklevel = colorConfig["blacklevel"].convert<double>();
whitelevel = colorConfig["whitelevel"].convert<double>();
RgbChannelTransform *transform = new RgbChannelTransform(threshold, gamma, blacklevel, whitelevel);
return transform;
}
LedString Hyperion::createLedString(const Poco::Dynamic::Var &ledsConfig, const ColorOrder deviceOrder) {
LedString ledString;
if (!ledsConfig.isArray()) {
throw std::runtime_error("leds config is not valid");
}
const std::string deviceOrderStr = colorOrderToString(deviceOrder);
Poco::DynamicStruct ledConfig;
for (unsigned i = 0; i < ledsConfig.size(); i++) {
ledConfig = ledsConfig[i].extract<Poco::DynamicStruct>();
Led led;
led.index = ledConfig["index"];
const Poco::DynamicStruct &hscanConfig = ledConfig["hscan"].extract<Poco::DynamicStruct>();
const Poco::DynamicStruct &vscanConfig = ledConfig["vscan"].extract<Poco::DynamicStruct>();
led.minX_frac = std::max(0.0, std::min(1.0, hscanConfig["minimum"].extract<double>()));
led.maxX_frac = std::max(0.0, std::min(1.0, hscanConfig["maximum"].extract<double>()));
led.minY_frac = std::max(0.0, std::min(1.0, vscanConfig["minimum"].extract<double>()));
led.maxY_frac = std::max(0.0, std::min(1.0, vscanConfig["maximum"].extract<double>()));
// Fix if the user swapped min and max
if (led.minX_frac > led.maxX_frac) {
std::swap(led.minX_frac, led.maxX_frac);
}
if (led.minY_frac > led.maxY_frac) {
std::swap(led.minY_frac, led.maxY_frac);
}
// Get the order of the rgb channels for this led (default is device order)
std::string ledOrderStr = deviceOrderStr;
if (ledConfig.contains("colorOrder"))
ledOrderStr = ledConfig["colorOrder"].toString();
led.colorOrder = stringToColorOrder(ledOrderStr);
ledString.leds().push_back(led);
}
// Make sure the leds are sorted (on their indices)
std::sort(ledString.leds().begin(), ledString.leds().end(), [](const Led &lhs, const Led &rhs) {
return lhs.index < rhs.index;
});
return ledString;
}
LedDevice *Hyperion::createColorSmoothing(const Poco::DynamicStruct &smoothingConfig, LedDevice *ledDevice) {
std::string type = smoothingConfig["type"].toString();
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
if (type == "none") {
std::cout << "Not creating any smoothing" << std::endl;
return ledDevice;
}
else if (type == "linear") {
if (!smoothingConfig.contains("time_ms")) {
std::cout << "Unable to create smoothing of type linear because of missing parameter 'time_ms'"
<< std::endl;
}
else if (!smoothingConfig.contains("updateFrequency")) {
std::cout << "Unable to create smoothing of type linear because of missing parameter 'updateFrequency'"
<< std::endl;
}
else {
unsigned updateDelay = 0;
updateDelay = smoothingConfig["updateDelay"].extract<int>();
std::cout << "Creating linear smoothing" << std::endl;
return new LinearColorSmoothing(ledDevice,
smoothingConfig["updateFrequency"].extract<double>(),
smoothingConfig["time_ms"].extract<int>(),
updateDelay);
}
}
else {
std::cout << "Unable to create smoothing of type " << type << std::endl;
}
return ledDevice;
}
Hyperion::Hyperion(const Poco::DynamicStruct &config)
: _ledString(
createLedString(config["leds"], createColorOrder(config["device"].extract<Poco::DynamicStruct>()))),
_muxer(_ledString.count()), _raw2ledTransform(
createLedColorsTransform(_ledString.count(), config["color"].extract<Poco::DynamicStruct>())),
_device(LedDeviceFactory::construct(config["device"].extract<Poco::DynamicStruct>())), _timer(0, 0), _timerRunning() {
if (_device == nullptr) {
throw std::runtime_error("[ERROR] LED device could not be created");
}
if (!_raw2ledTransform->verifyTransforms()) {
throw std::runtime_error("Color transformation incorrectly set");
}
// initialize the image processor factory
ImageProcessorFactory::getInstance().init(
_ledString,
config["blackborderdetector"]["enable"].extract<bool>(), // TODO default true
config["blackborderdetector"]["threshold"].extract<double>()); // TODO default 0.01
// initialize the color smoothing filter
_device = createColorSmoothing(config["color"]["smoothing"].extract<Poco::DynamicStruct>(), _device);
#ifdef ENABLE_EFFECT_ENGINE
// create the effect engine
_effectEngine = new EffectEngine(this, config["effects"].extract<Poco::DynamicStruct>());
#endif
stopTimerEvent += Poco::delegate(this, &Hyperion::stopTimer);
// initialize the leds
update();
}
Hyperion::~Hyperion() {
// switch off all leds
clearall();
_device->switchOff();
stopTimerEvent -= Poco::delegate(this, &Hyperion::stopTimer);
#ifdef ENABLE_EFFECT_ENGINE
// delete the effect engine
delete _effectEngine;
#endif
// Delete the Led-Device object
delete _device;
// delete the color transform
delete _raw2ledTransform;
}
unsigned Hyperion::getLedCount() const {
return _ledString.count();
}
void Hyperion::setColor(int priority, const ColorRgb &color, const int timeout_ms, bool clearEffects) {
// create led output
std::vector<ColorRgb> ledColors(_ledString.count(), color);
// set colors
setColors(priority, ledColors, timeout_ms, clearEffects);
}
void Hyperion::setColors(int priority, const std::vector<ColorRgb> &ledColors, const int timeout_ms,
bool clearEffects) {
#ifdef ENABLE_EFFECT_ENGINE
// clear effects if this call does not come from an effect
if (clearEffects) {
_effectEngine->clearChannel(priority);
}
#endif
if (timeout_ms > 0) {
long timeoutTime = (Poco::Timestamp().epochMicroseconds() / 1000) + timeout_ms;
_muxer.setInput(priority, ledColors, timeoutTime);
}
else {
_muxer.setInput(priority, ledColors);
}
if (priority == _muxer.getCurrentPriority()) {
update();
}
}
const std::vector<std::string> &Hyperion::getTransformIds() const {
return _raw2ledTransform->getTransformIds();
}
ColorTransform *Hyperion::getTransform(const std::string &id) {
return _raw2ledTransform->getTransform(id);
}
void Hyperion::transformsUpdated() {
update();
}
void Hyperion::clear(int priority) {
if (_muxer.hasPriority(priority)) {
_muxer.clearInput(priority);
// update leds if necessary
if (priority < _muxer.getCurrentPriority()) {
update();
}
}
#ifdef ENABLE_EFFECT_ENGINE
// send clear signal to the effect engine
// (outside the check so the effect gets cleared even when the effect is not sending colors)
_effectEngine->clearChannel(priority);
#endif
}
void Hyperion::clearall() {
_muxer.clearAll();
// update leds
update();
#ifdef ENABLE_EFFECT_ENGINE
// send clearall signal to the effect engine
_effectEngine->clearAllChannels();
#endif
}
std::vector<int> Hyperion::getActivePriorities() const {
return _muxer.getPriorities();
}
const Hyperion::InputInfo &Hyperion::getPriorityInfo(const int priority) const {
return _muxer.getInputInfo(priority);
}
#ifdef ENABLE_EFFECT_ENGINE
const std::list<EffectDefinition> &Hyperion::getEffects() const {
return _effectEngine->getEffects();
}
int Hyperion::setEffect(const std::string &effectName, int priority, int timeout) {
return _effectEngine->runEffect(effectName, priority, timeout);
}
int Hyperion::setEffect(const std::string &effectName, const Poco::DynamicStruct &args, int priority, int timeout) {
return _effectEngine->runEffect(effectName, args, priority, timeout);
}
#endif
void Hyperion::startTimer(long timeout) {
_timerRunning++;
static Poco::TimerCallback<Hyperion> timerCallback(*this, &Hyperion::onTimer);
_timer.setStartInterval(timeout);
_timer.start(timerCallback);
}
void Hyperion::stopTimer() {
_timerRunning--;
_timer.stop();
update();
}
void Hyperion::update() {
static Poco::FastMutex mutex;
if (!mutex.tryLock()) {
return;
}
// Update the muxer, cleaning obsolete priorities
int64_t now = Poco::Timestamp().epochMicroseconds() / 1000;
_muxer.setCurrentTime(now);
// Obtain the current priority channel
int priority = _muxer.getCurrentPriority();
PriorityMuxer::InputInfo priorityInfo = _muxer.getInputInfo(priority);
long timeout_ms = priorityInfo.timeoutTime_ms > 0 ? (priorityInfo.timeoutTime_ms - now) : 0;
//std::cout << "update() current priorityInfo: " << priorityInfo << " - TO: " << timeout_ms << std::endl;
// Apply the transform to each led and color-channel
std::vector<ColorRgb> ledColors = _raw2ledTransform->applyTransform(priorityInfo.ledColors);
const std::vector<Led> &leds = _ledString.leds();
unsigned long i = 0;
for (ColorRgb &color : ledColors) {
const ColorOrder ledColorOrder = leds.at(i).colorOrder;
// correct the color byte order
switch (ledColorOrder) {
case ORDER_RGB:
// leave as it is
break;
case ORDER_BGR:
std::swap(color.red, color.blue);
break;
case ORDER_RBG:
std::swap(color.green, color.blue);
break;
case ORDER_GRB:
std::swap(color.red, color.green);
break;
case ORDER_GBR: {
uint8_t temp = color.red;
color.red = color.green;
color.green = color.blue;
color.blue = temp;
break;
}
case ORDER_BRG: {
uint8_t temp = color.red;
color.red = color.blue;
color.blue = color.green;
color.green = temp;
break;
}
}
i++;
}
// Write the data to the device
_device->write(ledColors);
// Start the timeout-timer
if (timeout_ms > 0) {
if (_timerRunning == 0) {
startTimer(timeout_ms);
}
} else if (_timerRunning > 0) {
stopTimer();
}
mutex.unlock();
}
void Hyperion::onTimer(Poco::Timer &timer) {
stopTimerEvent.notifyAsync(nullptr);
}
| 34.509395 | 128 | 0.631458 | juanesf |
b434f81bf3017f6b445839273cee1ca131946154 | 2,389 | cpp | C++ | aqualectrix/sorter/sortProcess.cpp | aqualectrix/dbpf | 5bada102fddc24d9332f4de60c573ed06b722453 | [
"Unlicense"
] | null | null | null | aqualectrix/sorter/sortProcess.cpp | aqualectrix/dbpf | 5bada102fddc24d9332f4de60c573ed06b722453 | [
"Unlicense"
] | null | null | null | aqualectrix/sorter/sortProcess.cpp | aqualectrix/dbpf | 5bada102fddc24d9332f4de60c573ed06b722453 | [
"Unlicense"
] | null | null | null | /*
* sortProcess.cpp :
* Changes all sortindexes in the file to the given index.
*/
#include <iostream>
#include <string>
#include <vector>
#include "../../CatOfEvilGenius/library/DBPF.h"
#include "../../CatOfEvilGenius/library/DBPF_types.h"
#include "../../CatOfEvilGenius/library/DBPF_BINX.h"
using namespace std;
extern "C" // for exporting to shared library for use in Python
bool sortProcess(const char* filename, const int index) {
// extra crunchy goodness for restoring state after outputting in hex format
// ios_base::fmtflags f(cout.flags());
// clog << endl << "Sorting " << filename << " into index " << hex << index << "..." << endl;
// cout.flags(f);
DBPFtype package;
vector<DBPF_resourceType*> resources;
// Types that should be decompressed and loaded when opening the file.
vector<unsigned int> typesToInit;
typesToInit.push_back(DBPF_BINX);
// Open package file and read/populate chosen (typesToInit) resources.
if(!readPackage(filename, package, typesToInit, resources)) {
cerr << "Opening and reading from " << filename << " failed. Sorting aborted." << endl;
return false;
}
// Set all sortindices
int item_count = resources.size();
DBPF_resourceType* pResource = NULL;
for (int i = 0; i < item_count; i++) {
pResource = resources[i];
if (NULL == pResource) {
continue;
}
if (DBPF_BINX == pResource->getType()) {
if (((DBPF_BINXtype*)pResource)->setSortIndex(index)) {
// clog << "\t" << "Set BINX resource " << i << "." << endl;
}
}
}
// clog << "Sorting complete!" << endl;
// Write back to file
// clog << endl << "Overwriting file " << filename << "..." << endl;
bool write_success = writeCompressedPackage(filename, package, resources);
if (!write_success) {
cerr << "Writing to file " << filename << " failed. File may be corrupted... " <<
"or you may have the file open somewhere else (SimPE, maybe?). " <<
"If so, close the file elsewhere and try again." << endl;
}
// else {
// clog << "File written!" << endl;
// }
// Clean up
if (!resources.empty()) {
size_t vec_size = resources.size();
for (size_t i = 0; i < vec_size; i++) {
if (resources[i] != NULL) {
delete resources[i];
resources[i] = NULL;
}
resources.clear();
}
}
return write_success;
}
| 29.134146 | 95 | 0.621599 | aqualectrix |
b43b621485333f50997dbf39fbaa97849e350bc6 | 220,487 | cpp | C++ | src/game/ChatCommands/Level3.cpp | tbayart/mangostwoserver | fc26f650b9f72c1f7376207f9b9d3fdf66387a1e | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/game/ChatCommands/Level3.cpp | tbayart/mangostwoserver | fc26f650b9f72c1f7376207f9b9d3fdf66387a1e | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/game/ChatCommands/Level3.cpp | tbayart/mangostwoserver | fc26f650b9f72c1f7376207f9b9d3fdf66387a1e | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | /**
* MaNGOS is a full featured server for World of Warcraft, supporting
* the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
*
* Copyright (C) 2005-2017 MaNGOS project <https://getmangos.eu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* World of Warcraft, and all World of Warcraft or Warcraft art, images,
* and lore are copyrighted by Blizzard Entertainment, Inc.
*/
#include "Common.h"
#include "Database/DatabaseEnv.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "World.h"
#include "ObjectMgr.h"
#include "AccountMgr.h"
#include "PlayerDump.h"
#include "SpellMgr.h"
#include "Player.h"
#include "Opcodes.h"
#include "GameObject.h"
#include "Chat.h"
#include "Log.h"
#include "Guild.h"
#include "GuildMgr.h"
#include "ObjectAccessor.h"
#include "MapManager.h"
#include "MassMailMgr.h"
#include "ScriptMgr.h"
#include "Language.h"
#include "GridNotifiersImpl.h"
#include "CellImpl.h"
#include "Weather.h"
#include "PointMovementGenerator.h"
#include "PathFinder.h"
#include "TargetedMovementGenerator.h"
#include "SkillDiscovery.h"
#include "SkillExtraItems.h"
#include "SystemConfig.h"
#include "Config/Config.h"
#include "Mail.h"
#include "Util.h"
#include "ItemEnchantmentMgr.h"
#include "BattleGround/BattleGroundMgr.h"
#include "MapPersistentStateMgr.h"
#include "InstanceData.h"
#include "CreatureEventAIMgr.h"
#include "DBCEnums.h"
#include "AuctionHouseBot/AuctionHouseBot.h"
#include "SQLStorages.h"
static uint32 ahbotQualityIds[MAX_AUCTION_QUALITY] =
{
LANG_AHBOT_QUALITY_GREY, LANG_AHBOT_QUALITY_WHITE,
LANG_AHBOT_QUALITY_GREEN, LANG_AHBOT_QUALITY_BLUE,
LANG_AHBOT_QUALITY_PURPLE, LANG_AHBOT_QUALITY_ORANGE,
LANG_AHBOT_QUALITY_YELLOW
};
bool ChatHandler::HandleAHBotItemsAmountCommand(char* args)
{
uint32 qVals[MAX_AUCTION_QUALITY];
for (int i = 0; i < MAX_AUCTION_QUALITY; ++i)
if (!ExtractUInt32(&args, qVals[i]))
{ return false; }
sAuctionBot.SetItemsAmount(qVals);
for (int i = 0; i < MAX_AUCTION_QUALITY; ++i)
{ PSendSysMessage(LANG_AHBOT_ITEMS_AMOUNT, GetMangosString(ahbotQualityIds[i]), sAuctionBotConfig.getConfigItemQualityAmount(AuctionQuality(i))); }
return true;
}
template<int Q>
bool ChatHandler::HandleAHBotItemsAmountQualityCommand(char* args)
{
uint32 qVal;
if (!ExtractUInt32(&args, qVal))
{ return false; }
sAuctionBot.SetItemsAmountForQuality(AuctionQuality(Q), qVal);
PSendSysMessage(LANG_AHBOT_ITEMS_AMOUNT, GetMangosString(ahbotQualityIds[Q]),
sAuctionBotConfig.getConfigItemQualityAmount(AuctionQuality(Q)));
return true;
}
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREY>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_WHITE>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREEN>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_BLUE>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_PURPLE>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_ORANGE>(char*);
template bool ChatHandler::HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_YELLOW>(char*);
bool ChatHandler::HandleAHBotItemsRatioCommand(char* args)
{
uint32 rVal[MAX_AUCTION_HOUSE_TYPE];
for (int i = 0; i < MAX_AUCTION_HOUSE_TYPE; ++i)
if (!ExtractUInt32(&args, rVal[i]))
{ return false; }
sAuctionBot.SetItemsRatio(rVal[0], rVal[1], rVal[2]);
for (int i = 0; i < MAX_AUCTION_HOUSE_TYPE; ++i)
{ PSendSysMessage(LANG_AHBOT_ITEMS_RATIO, AuctionBotConfig::GetHouseTypeName(AuctionHouseType(i)), sAuctionBotConfig.getConfigItemAmountRatio(AuctionHouseType(i))); }
return true;
}
template<int H>
bool ChatHandler::HandleAHBotItemsRatioHouseCommand(char* args)
{
uint32 rVal;
if (!ExtractUInt32(&args, rVal))
{ return false; }
sAuctionBot.SetItemsRatioForHouse(AuctionHouseType(H), rVal);
PSendSysMessage(LANG_AHBOT_ITEMS_RATIO, AuctionBotConfig::GetHouseTypeName(AuctionHouseType(H)), sAuctionBotConfig.getConfigItemAmountRatio(AuctionHouseType(H)));
return true;
}
template bool ChatHandler::HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_ALLIANCE>(char*);
template bool ChatHandler::HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_HORDE>(char*);
template bool ChatHandler::HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_NEUTRAL>(char*);
bool ChatHandler::HandleAHBotRebuildCommand(char* args)
{
bool all = false;
if (*args)
{
if (!ExtractLiteralArg(&args, "all"))
{ return false; }
all = true;
}
sAuctionBot.Rebuild(all);
return true;
}
bool ChatHandler::HandleAHBotReloadCommand(char* /*args*/)
{
if (sAuctionBot.ReloadAllConfig())
{
SendSysMessage(LANG_AHBOT_RELOAD_OK);
return true;
}
else
{
SendSysMessage(LANG_AHBOT_RELOAD_FAIL);
SetSentErrorMessage(true);
return false;
}
}
bool ChatHandler::HandleAHBotStatusCommand(char* args)
{
bool all = false;
if (*args)
{
if (!ExtractLiteralArg(&args, "all"))
{ return false; }
all = true;
}
AuctionHouseBotStatusInfo statusInfo;
sAuctionBot.PrepareStatusInfos(statusInfo);
if (!m_session)
{
SendSysMessage(LANG_AHBOT_STATUS_BAR_CONSOLE);
SendSysMessage(LANG_AHBOT_STATUS_TITLE1_CONSOLE);
SendSysMessage(LANG_AHBOT_STATUS_MIDBAR_CONSOLE);
}
else
{ SendSysMessage(LANG_AHBOT_STATUS_TITLE1_CHAT); }
uint32 fmtId = m_session ? LANG_AHBOT_STATUS_FORMAT_CHAT : LANG_AHBOT_STATUS_FORMAT_CONSOLE;
PSendSysMessage(fmtId, GetMangosString(LANG_AHBOT_STATUS_ITEM_COUNT),
statusInfo[AUCTION_HOUSE_ALLIANCE].ItemsCount,
statusInfo[AUCTION_HOUSE_HORDE].ItemsCount,
statusInfo[AUCTION_HOUSE_NEUTRAL].ItemsCount,
statusInfo[AUCTION_HOUSE_ALLIANCE].ItemsCount +
statusInfo[AUCTION_HOUSE_HORDE].ItemsCount +
statusInfo[AUCTION_HOUSE_NEUTRAL].ItemsCount);
if (all)
{
PSendSysMessage(fmtId, GetMangosString(LANG_AHBOT_STATUS_ITEM_RATIO),
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_ALLIANCE_ITEM_AMOUNT_RATIO),
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_HORDE_ITEM_AMOUNT_RATIO),
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_NEUTRAL_ITEM_AMOUNT_RATIO),
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_ALLIANCE_ITEM_AMOUNT_RATIO) +
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_HORDE_ITEM_AMOUNT_RATIO) +
sAuctionBotConfig.getConfig(CONFIG_UINT32_AHBOT_NEUTRAL_ITEM_AMOUNT_RATIO));
if (!m_session)
{
SendSysMessage(LANG_AHBOT_STATUS_BAR_CONSOLE);
SendSysMessage(LANG_AHBOT_STATUS_TITLE2_CONSOLE);
SendSysMessage(LANG_AHBOT_STATUS_MIDBAR_CONSOLE);
}
else
{ SendSysMessage(LANG_AHBOT_STATUS_TITLE2_CHAT); }
for (int i = 0; i < MAX_AUCTION_QUALITY; ++i)
PSendSysMessage(fmtId, GetMangosString(ahbotQualityIds[i]),
statusInfo[AUCTION_HOUSE_ALLIANCE].QualityInfo[i],
statusInfo[AUCTION_HOUSE_HORDE].QualityInfo[i],
statusInfo[AUCTION_HOUSE_NEUTRAL].QualityInfo[i],
sAuctionBotConfig.getConfigItemQualityAmount(AuctionQuality(i)));
}
if (!m_session)
{ SendSysMessage(LANG_AHBOT_STATUS_BAR_CONSOLE); }
return true;
}
// reload commands
bool ChatHandler::HandleReloadAllCommand(char* /*args*/)
{
HandleReloadSkillFishingBaseLevelCommand((char*)"");
HandleReloadAllAchievementCommand((char*)"");
HandleReloadAllAreaCommand((char*)"");
HandleReloadAutoBroadcastCommand((char*)"");
HandleReloadAllEventAICommand((char*)"");
HandleReloadAllLootCommand((char*)"");
HandleReloadAllNpcCommand((char*)"");
HandleReloadAllQuestCommand((char*)"");
HandleReloadAllSpellCommand((char*)"");
HandleReloadAllItemCommand((char*)"");
HandleReloadAllGossipsCommand((char*)"");
HandleReloadAllLocalesCommand((char*)"");
HandleReloadMailLevelRewardCommand((char*)"");
HandleReloadCommandCommand((char*)"");
HandleReloadReservedNameCommand((char*)"");
HandleReloadMangosStringCommand((char*)"");
HandleReloadGameTeleCommand((char*)"");
return true;
}
bool ChatHandler::HandleReloadAllAchievementCommand(char* /*args*/)
{
HandleReloadAchievementCriteriaRequirementCommand((char*)"");
HandleReloadAchievementRewardCommand((char*)"");
return true;
}
bool ChatHandler::HandleReloadAllAreaCommand(char* /*args*/)
{
// HandleReloadQuestAreaTriggersCommand((char*)""); -- reloaded in HandleReloadAllQuestCommand
HandleReloadAreaTriggerTeleportCommand((char*)"");
HandleReloadAreaTriggerTavernCommand((char*)"");
HandleReloadGameGraveyardZoneCommand((char*)"");
return true;
}
bool ChatHandler::HandleReloadAllLootCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables...");
LoadLootTables();
SendGlobalSysMessage("DB tables `*_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAllNpcCommand(char* args)
{
if (*args != 'a') // will be reloaded from all_gossips
{ HandleReloadNpcGossipCommand((char*)"a"); }
HandleReloadNpcTrainerCommand((char*)"a");
HandleReloadNpcVendorCommand((char*)"a");
HandleReloadPointsOfInterestCommand((char*)"a");
HandleReloadSpellClickSpellsCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllQuestCommand(char* /*args*/)
{
HandleReloadQuestAreaTriggersCommand((char*)"a");
HandleReloadQuestPOICommand((char*)"a");
HandleReloadQuestTemplateCommand((char*)"a");
sLog.outString("Re-Loading Quests Relations...");
sObjectMgr.LoadQuestRelations();
SendGlobalSysMessage("DB tables `*_questrelation` and `*_involvedrelation` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAllScriptsCommand(char* /*args*/)
{
if (sScriptMgr.IsScriptScheduled())
{
PSendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
sLog.outString("Re-Loading Scripts...");
HandleReloadDBScriptsOnCreatureDeathCommand((char*)"a");
HandleReloadDBScriptsOnGoUseCommand((char*)"a");
HandleReloadDBScriptsOnGossipCommand((char*)"a");
HandleReloadDBScriptsOnEventCommand((char*)"a");
HandleReloadDBScriptsOnQuestEndCommand((char*)"a");
HandleReloadDBScriptsOnQuestStartCommand((char*)"a");
HandleReloadDBScriptsOnSpellCommand((char*)"a");
SendGlobalSysMessage("DB tables `*_scripts` reloaded.");
HandleReloadDbScriptStringCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllEventAICommand(char* /*args*/)
{
HandleReloadEventAITextsCommand((char*)"a");
HandleReloadEventAISummonsCommand((char*)"a");
HandleReloadEventAIScriptsCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllSpellCommand(char* /*args*/)
{
HandleReloadSkillDiscoveryTemplateCommand((char*)"a");
HandleReloadSkillExtraItemTemplateCommand((char*)"a");
HandleReloadSpellAreaCommand((char*)"a");
HandleReloadSpellChainCommand((char*)"a");
HandleReloadSpellElixirCommand((char*)"a");
HandleReloadSpellLearnSpellCommand((char*)"a");
HandleReloadSpellProcEventCommand((char*)"a");
HandleReloadSpellBonusesCommand((char*)"a");
HandleReloadSpellProcItemEnchantCommand((char*)"a");
HandleReloadSpellScriptTargetCommand((char*)"a");
HandleReloadSpellTargetPositionCommand((char*)"a");
HandleReloadSpellThreatsCommand((char*)"a");
HandleReloadSpellPetAurasCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllGossipsCommand(char* args)
{
if (*args != 'a') // already reload from all_scripts
{ HandleReloadDBScriptsOnGossipCommand((char*)"a"); }
HandleReloadGossipMenuCommand((char*)"a");
HandleReloadNpcGossipCommand((char*)"a");
HandleReloadPointsOfInterestCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllItemCommand(char* /*args*/)
{
HandleReloadPageTextsCommand((char*)"a");
HandleReloadItemConvertCommand((char*)"a");
HandleReloadItemEnchantementsCommand((char*)"a");
HandleReloadItemRequiredTragetCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadAllLocalesCommand(char* /*args*/)
{
HandleReloadLocalesAchievementRewardCommand((char*)"a");
HandleReloadLocalesCreatureCommand((char*)"a");
HandleReloadLocalesGameobjectCommand((char*)"a");
HandleReloadLocalesGossipMenuOptionCommand((char*)"a");
HandleReloadLocalesItemCommand((char*)"a");
HandleReloadLocalesNpcTextCommand((char*)"a");
HandleReloadLocalesPageTextCommand((char*)"a");
HandleReloadLocalesPointsOfInterestCommand((char*)"a");
HandleReloadLocalesQuestCommand((char*)"a");
return true;
}
bool ChatHandler::HandleReloadConfigCommand(char* /*args*/)
{
sLog.outString("Re-Loading config settings...");
sWorld.LoadConfigSettings(true);
sMapMgr.InitializeVisibilityDistanceInfo();
SendGlobalSysMessage("World config settings reloaded.");
return true;
}
bool ChatHandler::HandleReloadAchievementCriteriaRequirementCommand(char* /*args*/)
{
sLog.outString("Re-Loading Additional Achievement Criteria Requirements Data...");
sAchievementMgr.LoadAchievementCriteriaRequirements();
SendGlobalSysMessage("DB table `achievement_criteria_requirement` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAchievementRewardCommand(char* /*args*/)
{
sLog.outString("Re-Loading Achievement Reward Data...");
sAchievementMgr.LoadRewards();
SendGlobalSysMessage("DB table `achievement_reward` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAreaTriggerTavernCommand(char* /*args*/)
{
sLog.outString("Re-Loading Tavern Area Triggers...");
sObjectMgr.LoadTavernAreaTriggers();
SendGlobalSysMessage("DB table `areatrigger_tavern` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAreaTriggerTeleportCommand(char* /*args*/)
{
sLog.outString("Re-Loading AreaTrigger teleport definitions...");
sObjectMgr.LoadAreaTriggerTeleports();
SendGlobalSysMessage("DB table `areatrigger_teleport` reloaded.");
return true;
}
bool ChatHandler::HandleReloadAutoBroadcastCommand(char* /*args*/)
{
sLog.outString("Re-Loading broadcast strings...");
sWorld.LoadBroadcastStrings();
SendGlobalSysMessage("Broadcast strings reloaded.");
return true;
}
bool ChatHandler::HandleReloadCommandCommand(char* /*args*/)
{
load_command_table = true;
SendGlobalSysMessage("DB table `command` will be reloaded at next chat command use.");
return true;
}
bool ChatHandler::HandleReloadCreatureQuestRelationsCommand(char* /*args*/)
{
sLog.outString("Loading Quests Relations... (`creature_questrelation`)");
sObjectMgr.LoadCreatureQuestRelations();
SendGlobalSysMessage("DB table `creature_questrelation` (creature quest givers) reloaded.");
return true;
}
bool ChatHandler::HandleReloadCreatureQuestInvRelationsCommand(char* /*args*/)
{
sLog.outString("Loading Quests Relations... (`creature_involvedrelation`)");
sObjectMgr.LoadCreatureInvolvedRelations();
SendGlobalSysMessage("DB table `creature_involvedrelation` (creature quest takers) reloaded.");
return true;
}
bool ChatHandler::HandleReloadConditionsCommand(char* /*args*/)
{
sLog.outString("Re-Loading `conditions`... ");
sObjectMgr.LoadConditions();
SendGlobalSysMessage("DB table `conditions` reloaded.");
return true;
}
bool ChatHandler::HandleReloadGossipMenuCommand(char* /*args*/)
{
sObjectMgr.LoadGossipMenus();
SendGlobalSysMessage("DB tables `gossip_menu` and `gossip_menu_option` reloaded.");
return true;
}
bool ChatHandler::HandleReloadGOQuestRelationsCommand(char* /*args*/)
{
sLog.outString("Loading Quests Relations... (`gameobject_questrelation`)");
sObjectMgr.LoadGameobjectQuestRelations();
SendGlobalSysMessage("DB table `gameobject_questrelation` (gameobject quest givers) reloaded.");
return true;
}
bool ChatHandler::HandleReloadGOQuestInvRelationsCommand(char* /*args*/)
{
sLog.outString("Loading Quests Relations... (`gameobject_involvedrelation`)");
sObjectMgr.LoadGameobjectInvolvedRelations();
SendGlobalSysMessage("DB table `gameobject_involvedrelation` (gameobject quest takers) reloaded.");
return true;
}
bool ChatHandler::HandleReloadQuestAreaTriggersCommand(char* /*args*/)
{
sLog.outString("Re-Loading Quest Area Triggers...");
sObjectMgr.LoadQuestAreaTriggers();
SendGlobalSysMessage("DB table `areatrigger_involvedrelation` (quest area triggers) reloaded.");
return true;
}
bool ChatHandler::HandleReloadQuestTemplateCommand(char* /*args*/)
{
sLog.outString("Re-Loading Quest Templates...");
sObjectMgr.LoadQuests();
SendGlobalSysMessage("DB table `quest_template` (quest definitions) reloaded.");
/// dependent also from `gameobject` but this table not reloaded anyway
sLog.outString("Re-Loading GameObjects for quests...");
sObjectMgr.LoadGameObjectForQuests();
SendGlobalSysMessage("Data GameObjects for quests reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesCreatureCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`creature_loot_template`)");
LoadLootTemplates_Creature();
LootTemplates_Creature.CheckLootRefs();
SendGlobalSysMessage("DB table `creature_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesDisenchantCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`disenchant_loot_template`)");
LoadLootTemplates_Disenchant();
LootTemplates_Disenchant.CheckLootRefs();
SendGlobalSysMessage("DB table `disenchant_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesFishingCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`fishing_loot_template`)");
LoadLootTemplates_Fishing();
LootTemplates_Fishing.CheckLootRefs();
SendGlobalSysMessage("DB table `fishing_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesGameobjectCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`gameobject_loot_template`)");
LoadLootTemplates_Gameobject();
LootTemplates_Gameobject.CheckLootRefs();
SendGlobalSysMessage("DB table `gameobject_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesItemCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`item_loot_template`)");
LoadLootTemplates_Item();
LootTemplates_Item.CheckLootRefs();
SendGlobalSysMessage("DB table `item_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesMillingCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`milling_loot_template`)");
LoadLootTemplates_Milling();
LootTemplates_Milling.CheckLootRefs();
SendGlobalSysMessage("DB table `milling_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesPickpocketingCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`pickpocketing_loot_template`)");
LoadLootTemplates_Pickpocketing();
LootTemplates_Pickpocketing.CheckLootRefs();
SendGlobalSysMessage("DB table `pickpocketing_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesProspectingCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`prospecting_loot_template`)");
LoadLootTemplates_Prospecting();
LootTemplates_Prospecting.CheckLootRefs();
SendGlobalSysMessage("DB table `prospecting_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesMailCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`mail_loot_template`)");
LoadLootTemplates_Mail();
LootTemplates_Mail.CheckLootRefs();
SendGlobalSysMessage("DB table `mail_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesReferenceCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`reference_loot_template`)");
LoadLootTemplates_Reference();
SendGlobalSysMessage("DB table `reference_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesSkinningCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`skinning_loot_template`)");
LoadLootTemplates_Skinning();
LootTemplates_Skinning.CheckLootRefs();
SendGlobalSysMessage("DB table `skinning_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLootTemplatesSpellCommand(char* /*args*/)
{
sLog.outString("Re-Loading Loot Tables... (`spell_loot_template`)");
LoadLootTemplates_Spell();
LootTemplates_Spell.CheckLootRefs();
SendGlobalSysMessage("DB table `spell_loot_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadMangosStringCommand(char* /*args*/)
{
sLog.outString("Re-Loading mangos_string Table!");
sObjectMgr.LoadMangosStrings();
SendGlobalSysMessage("DB table `mangos_string` reloaded.");
return true;
}
bool ChatHandler::HandleReloadNpcGossipCommand(char* /*args*/)
{
sLog.outString("Re-Loading `npc_gossip` Table!");
sObjectMgr.LoadNpcGossips();
SendGlobalSysMessage("DB table `npc_gossip` reloaded.");
return true;
}
bool ChatHandler::HandleReloadNpcTextCommand(char* /*args*/)
{
sLog.outString("Re-Loading `npc_text` Table!");
sObjectMgr.LoadGossipText();
SendGlobalSysMessage("DB table `npc_text` reloaded.");
return true;
}
bool ChatHandler::HandleReloadNpcTrainerCommand(char* /*args*/)
{
sLog.outString("Re-Loading `npc_trainer_template` Table!");
sObjectMgr.LoadTrainerTemplates();
SendGlobalSysMessage("DB table `npc_trainer_template` reloaded.");
sLog.outString("Re-Loading `npc_trainer` Table!");
sObjectMgr.LoadTrainers();
SendGlobalSysMessage("DB table `npc_trainer` reloaded.");
return true;
}
bool ChatHandler::HandleReloadNpcVendorCommand(char* /*args*/)
{
// not safe reload vendor template tables independent...
sLog.outString("Re-Loading `npc_vendor_template` Table!");
sObjectMgr.LoadVendorTemplates();
SendGlobalSysMessage("DB table `npc_vendor_template` reloaded.");
sLog.outString("Re-Loading `npc_vendor` Table!");
sObjectMgr.LoadVendors();
SendGlobalSysMessage("DB table `npc_vendor` reloaded.");
return true;
}
bool ChatHandler::HandleReloadPointsOfInterestCommand(char* /*args*/)
{
sLog.outString("Re-Loading `points_of_interest` Table!");
sObjectMgr.LoadPointsOfInterest();
SendGlobalSysMessage("DB table `points_of_interest` reloaded.");
return true;
}
bool ChatHandler::HandleReloadQuestPOICommand(char* /*args*/)
{
sLog.outString("Re-Loading `quest_poi` and `quest_poi_points` Tables!");
sObjectMgr.LoadQuestPOI();
SendGlobalSysMessage("DB Table `quest_poi` and `quest_poi_points` reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellClickSpellsCommand(char* /*args*/)
{
sLog.outString("Re-Loading `npc_spellclick_spells` Table!");
sObjectMgr.LoadNPCSpellClickSpells();
SendGlobalSysMessage("DB table `npc_spellclick_spells` reloaded.");
return true;
}
bool ChatHandler::HandleReloadReservedNameCommand(char* /*args*/)
{
sLog.outString("Loading ReservedNames... (`reserved_name`)");
sObjectMgr.LoadReservedPlayersNames();
SendGlobalSysMessage("DB table `reserved_name` (player reserved names) reloaded.");
return true;
}
bool ChatHandler::HandleReloadReputationRewardRateCommand(char* /*args*/)
{
sLog.outString("Re-Loading `reputation_reward_rate` Table!");
sObjectMgr.LoadReputationRewardRate();
SendGlobalSysMessage("DB table `reputation_reward_rate` reloaded.");
return true;
}
bool ChatHandler::HandleReloadReputationSpilloverTemplateCommand(char* /*args*/)
{
sLog.outString("Re-Loading `reputation_spillover_template` Table!");
sObjectMgr.LoadReputationSpilloverTemplate();
SendGlobalSysMessage("DB table `reputation_spillover_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadSkillDiscoveryTemplateCommand(char* /*args*/)
{
sLog.outString("Re-Loading Skill Discovery Table...");
LoadSkillDiscoveryTable();
SendGlobalSysMessage("DB table `skill_discovery_template` (recipes discovered at crafting) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSkillExtraItemTemplateCommand(char* /*args*/)
{
sLog.outString("Re-Loading Skill Extra Item Table...");
LoadSkillExtraItemTable();
SendGlobalSysMessage("DB table `skill_extra_item_template` (extra item creation when crafting) reloaded.");
return true;
}
bool ChatHandler::HandleReloadScriptBindingCommand(char* /*args*/)
{
sLog.outString("Trying to re-load `script_binding` Table!");
if (sScriptMgr.ReloadScriptBinding())
SendGlobalSysMessage("DB table `script_binding` reloaded.");
else
SendSysMessage("DENIED: DB table `script_binding` is reloadable only in Debug build.");
return true;
}
bool ChatHandler::HandleReloadSkillFishingBaseLevelCommand(char* /*args*/)
{
sLog.outString("Re-Loading Skill Fishing base level requirements...");
sObjectMgr.LoadFishingBaseSkillLevel();
SendGlobalSysMessage("DB table `skill_fishing_base_level` (fishing base level for zone/subzone) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellAreaCommand(char* /*args*/)
{
sLog.outString("Re-Loading SpellArea Data...");
sSpellMgr.LoadSpellAreas();
SendGlobalSysMessage("DB table `spell_area` (spell dependences from area/quest/auras state) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellBonusesCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Bonus Data...");
sSpellMgr.LoadSpellBonuses();
SendGlobalSysMessage("DB table `spell_bonus_data` (spell damage/healing coefficients) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellChainCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Chain Data... ");
sSpellMgr.LoadSpellChains();
SendGlobalSysMessage("DB table `spell_chain` (spell ranks) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellElixirCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Elixir types...");
sSpellMgr.LoadSpellElixirs();
SendGlobalSysMessage("DB table `spell_elixir` (spell elixir types) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellLearnSpellCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Learn Spells...");
sSpellMgr.LoadSpellLearnSpells();
SendGlobalSysMessage("DB table `spell_learn_spell` reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellProcEventCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Proc Event conditions...");
sSpellMgr.LoadSpellProcEvents();
SendGlobalSysMessage("DB table `spell_proc_event` (spell proc trigger requirements) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellProcItemEnchantCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell Proc Item Enchant...");
sSpellMgr.LoadSpellProcItemEnchant();
SendGlobalSysMessage("DB table `spell_proc_item_enchant` (item enchantment ppm) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellScriptTargetCommand(char* /*args*/)
{
sLog.outString("Re-Loading SpellsScriptTarget...");
sSpellMgr.LoadSpellScriptTarget();
SendGlobalSysMessage("DB table `spell_script_target` (spell targets selection in case specific creature/GO requirements) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellTargetPositionCommand(char* /*args*/)
{
sLog.outString("Re-Loading spell target destination coordinates...");
sSpellMgr.LoadSpellTargetPositions();
SendGlobalSysMessage("DB table `spell_target_position` (destination coordinates for spell targets) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellThreatsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Aggro Spells Definitions...");
sSpellMgr.LoadSpellThreats();
SendGlobalSysMessage("DB table `spell_threat` (spell aggro definitions) reloaded.");
return true;
}
bool ChatHandler::HandleReloadSpellPetAurasCommand(char* /*args*/)
{
sLog.outString("Re-Loading Spell pet auras...");
sSpellMgr.LoadSpellPetAuras();
SendGlobalSysMessage("DB table `spell_pet_auras` reloaded.");
return true;
}
bool ChatHandler::HandleReloadPageTextsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Page Texts...");
sObjectMgr.LoadPageTexts();
SendGlobalSysMessage("DB table `page_texts` reloaded.");
return true;
}
bool ChatHandler::HandleReloadItemEnchantementsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Item Random Enchantments Table...");
LoadRandomEnchantmentsTable();
SendGlobalSysMessage("DB table `item_enchantment_template` reloaded.");
return true;
}
bool ChatHandler::HandleReloadItemConvertCommand(char* /*args*/)
{
sLog.outString("Re-Loading Item Converts Table...");
sObjectMgr.LoadItemConverts();
SendGlobalSysMessage("DB table `item_convert` reloaded.");
return true;
}
bool ChatHandler::HandleReloadItemRequiredTragetCommand(char* /*args*/)
{
sLog.outString("Re-Loading Item Required Targets Table...");
sObjectMgr.LoadItemRequiredTarget();
SendGlobalSysMessage("DB table `item_required_target` reloaded.");
return true;
}
bool ChatHandler::HandleReloadBattleEventCommand(char* /*args*/)
{
sLog.outString("Re-Loading BattleGround Eventindexes...");
sBattleGroundMgr.LoadBattleEventIndexes();
SendGlobalSysMessage("DB table `gameobject_battleground` and `creature_battleground` reloaded.");
return true;
}
bool ChatHandler::HandleReloadEventAITextsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Texts from `creature_ai_texts`...");
sEventAIMgr.LoadCreatureEventAI_Texts(true);
SendGlobalSysMessage("DB table `creature_ai_texts` reloaded.");
return true;
}
bool ChatHandler::HandleReloadEventAISummonsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Summons from `creature_ai_summons`...");
sEventAIMgr.LoadCreatureEventAI_Summons(true);
SendGlobalSysMessage("DB table `creature_ai_summons` reloaded.");
return true;
}
bool ChatHandler::HandleReloadEventAIScriptsCommand(char* /*args*/)
{
sLog.outString("Re-Loading Scripts from `creature_ai_scripts`...");
sEventAIMgr.LoadCreatureEventAI_Scripts();
SendGlobalSysMessage("DB table `creature_ai_scripts` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDbScriptStringCommand(char* /*args*/)
{
sLog.outString("Re-Loading Script strings from `db_script_string`...");
sScriptMgr.LoadDbScriptStrings();
SendGlobalSysMessage("DB table `db_script_string` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnGossipCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_GOSSIP]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_GOSSIP);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_GOSSIP]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnSpellCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_SPELL]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_SPELL);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_SPELL]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnQuestStartCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_QUEST_START]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_QUEST_START);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_QUEST_START]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnQuestEndCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_QUEST_END]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_QUEST_END);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_QUEST_END]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnEventCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_EVENT]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_EVENT);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_EVENT]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnGoUseCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_GO[_TEMPLATE]_USE]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_GO_USE);
sScriptMgr.LoadDbScripts(DBS_ON_GOT_USE);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_GO[_TEMPLATE]_USE]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadDBScriptsOnCreatureDeathCommand(char* args)
{
if (sScriptMgr.IsScriptScheduled())
{
SendSysMessage("DB scripts used currently, please attempt reload later.");
SetSentErrorMessage(true);
return false;
}
if (*args != 'a')
{ sLog.outString("Re-Loading Scripts from `db_scripts [type = DBS_ON_CREATURE_DEATH]`..."); }
sScriptMgr.LoadDbScripts(DBS_ON_CREATURE_DEATH);
if (*args != 'a')
SendGlobalSysMessage("DB table `db_scripts [type = DBS_ON_CREATURE_DEATH]` reloaded.");
return true;
}
bool ChatHandler::HandleReloadGameGraveyardZoneCommand(char* /*args*/)
{
sLog.outString("Re-Loading Graveyard-zone links...");
sObjectMgr.LoadGraveyardZones();
SendGlobalSysMessage("DB table `game_graveyard_zone` reloaded.");
return true;
}
bool ChatHandler::HandleReloadGameTeleCommand(char* /*args*/)
{
sLog.outString("Re-Loading Game Tele coordinates...");
sObjectMgr.LoadGameTele();
SendGlobalSysMessage("DB table `game_tele` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesAchievementRewardCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Achievement Reward Data...");
sAchievementMgr.LoadRewardLocales();
SendGlobalSysMessage("DB table `locales_achievement_reward` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesCreatureCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Creature ...");
sObjectMgr.LoadCreatureLocales();
SendGlobalSysMessage("DB table `locales_creature` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesGameobjectCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Gameobject ... ");
sObjectMgr.LoadGameObjectLocales();
SendGlobalSysMessage("DB table `locales_gameobject` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesGossipMenuOptionCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Gossip Menu Option ... ");
sObjectMgr.LoadGossipMenuItemsLocales();
SendGlobalSysMessage("DB table `locales_gossip_menu_option` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesItemCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Item ... ");
sObjectMgr.LoadItemLocales();
SendGlobalSysMessage("DB table `locales_item` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesNpcTextCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales NPC Text ... ");
sObjectMgr.LoadGossipTextLocales();
SendGlobalSysMessage("DB table `locales_npc_text` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesPageTextCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Page Text ... ");
sObjectMgr.LoadPageTextLocales();
SendGlobalSysMessage("DB table `locales_page_text` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesPointsOfInterestCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Points Of Interest ... ");
sObjectMgr.LoadPointOfInterestLocales();
SendGlobalSysMessage("DB table `locales_points_of_interest` reloaded.");
return true;
}
bool ChatHandler::HandleReloadLocalesQuestCommand(char* /*args*/)
{
sLog.outString("Re-Loading Locales Quest ... ");
sObjectMgr.LoadQuestLocales();
SendGlobalSysMessage("DB table `locales_quest` reloaded.");
return true;
}
bool ChatHandler::HandleReloadMailLevelRewardCommand(char* /*args*/)
{
sLog.outString("Re-Loading Player level dependent mail rewards...");
sObjectMgr.LoadMailLevelRewards();
SendGlobalSysMessage("DB table `mail_level_reward` reloaded.");
return true;
}
bool ChatHandler::HandleReloadCreaturesStatsCommand(char* /*args*/)
{
sLog.outString("Re-Loading stats data...");
sObjectMgr.LoadCreatureClassLvlStats();
SendGlobalSysMessage("DB table `creature_template_classlevelstats` reloaded.");
return true;
}
bool ChatHandler::HandleLoadScriptsCommand(char* args)
{
if (!*args)
{ return false; }
switch (sScriptMgr.LoadScriptLibrary(args))
{
case SCRIPT_LOAD_OK:
sWorld.SendWorldText(LANG_SCRIPTS_RELOADED_ANNOUNCE);
SendSysMessage(LANG_SCRIPTS_RELOADED_OK);
break;
case SCRIPT_LOAD_ERR_NOT_FOUND:
SendSysMessage(LANG_SCRIPTS_NOT_FOUND);
break;
case SCRIPT_LOAD_ERR_WRONG_API:
SendSysMessage(LANG_SCRIPTS_WRONG_API);
break;
case SCRIPT_LOAD_ERR_OUTDATED:
SendSysMessage(LANG_SCRIPTS_OUTDATED);
break;
}
return true;
}
bool ChatHandler::HandleAccountSetGmLevelCommand(char* args)
{
char* accountStr = ExtractOptNotLastArg(&args);
std::string targetAccountName;
Player* targetPlayer = NULL;
uint32 targetAccountId = ExtractAccountId(&accountStr, &targetAccountName, &targetPlayer);
if (!targetAccountId)
{ return false; }
/// only target player different from self allowed
if (GetAccountId() == targetAccountId)
{ return false; }
int32 gm;
if (!ExtractInt32(&args, gm))
{ return false; }
if (gm < SEC_PLAYER || gm > SEC_ADMINISTRATOR)
{
SendSysMessage(LANG_BAD_VALUE);
SetSentErrorMessage(true);
return false;
}
/// can set security level only for target with less security and to less security that we have
/// This will reject self apply by specify account name
if (HasLowerSecurityAccount(NULL, targetAccountId, true))
{ return false; }
/// account can't set security to same or grater level, need more power GM or console
AccountTypes plSecurity = GetAccessLevel();
if (AccountTypes(gm) >= plSecurity)
{
SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
SetSentErrorMessage(true);
return false;
}
if (targetPlayer)
{
ChatHandler(targetPlayer).PSendSysMessage(LANG_YOURS_SECURITY_CHANGED, GetNameLink().c_str(), gm);
targetPlayer->GetSession()->SetSecurity(AccountTypes(gm));
}
PSendSysMessage(LANG_YOU_CHANGE_SECURITY, targetAccountName.c_str(), gm);
LoginDatabase.PExecute("UPDATE account SET gmlevel = '%i' WHERE id = '%u'", gm, targetAccountId);
return true;
}
/// Set password for account
bool ChatHandler::HandleAccountSetPasswordCommand(char* args)
{
///- Get the command line arguments
std::string account_name;
uint32 targetAccountId = ExtractAccountId(&args, &account_name);
if (!targetAccountId)
{ return false; }
// allow or quoted string with possible spaces or literal without spaces
char* szPassword1 = ExtractQuotedOrLiteralArg(&args);
char* szPassword2 = ExtractQuotedOrLiteralArg(&args);
if (!szPassword1 || !szPassword2)
{ return false; }
/// can set password only for target with less security
/// This is also reject self apply in fact
if (HasLowerSecurityAccount(NULL, targetAccountId, true))
{ return false; }
if (strcmp(szPassword1, szPassword2))
{
SendSysMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
SetSentErrorMessage(true);
return false;
}
AccountOpResult result = sAccountMgr.ChangePassword(targetAccountId, szPassword1);
switch (result)
{
case AOR_OK:
SendSysMessage(LANG_COMMAND_PASSWORD);
break;
case AOR_NAME_NOT_EXIST:
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, account_name.c_str());
SetSentErrorMessage(true);
return false;
case AOR_PASS_TOO_LONG:
SendSysMessage(LANG_PASSWORD_TOO_LONG);
SetSentErrorMessage(true);
return false;
default:
SendSysMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
SetSentErrorMessage(true);
return false;
}
// OK, but avoid normal report for hide passwords, but log use command for anyone
char msg[100];
snprintf(msg, 100, ".account set password %s *** ***", account_name.c_str());
LogCommand(msg);
SetSentErrorMessage(true);
return false;
}
void ChatHandler::ShowAchievementCriteriaListHelper(AchievementCriteriaEntry const* criEntry, AchievementEntry const* achEntry, LocaleConstant loc, Player* target /*= NULL*/)
{
std::ostringstream ss;
if (m_session)
{
ss << criEntry->ID << " - |cffffffff|Hachievement_criteria:" << criEntry->ID << "|h[" << criEntry->name[loc] << " " << localeNames[loc] << "]|h|r";
}
else
ss << criEntry->ID << " - " << criEntry->name[loc] << " " << localeNames[loc];
if (target)
ss << " = " << target->GetAchievementMgr().GetCriteriaProgressCounter(criEntry);
if (achEntry->flags & ACHIEVEMENT_FLAG_COUNTER)
ss << GetMangosString(LANG_COUNTER);
else
{
ss << " [" << AchievementMgr::GetCriteriaProgressMaxCounter(criEntry, achEntry) << "]";
if (target && target->GetAchievementMgr().IsCompletedCriteria(criEntry, achEntry))
ss << GetMangosString(LANG_COMPLETE);
}
SendSysMessage(ss.str().c_str());
}
bool ChatHandler::HandleAchievementCommand(char* args)
{
char* nameStr = ExtractOptNotLastArg(&args);
Player* target = NULL;
if (nameStr)
{
if (!ExtractPlayerTarget(&nameStr, &target))
return false;
}
else
target = getSelectedPlayer();
uint32 achId;
if (!ExtractUint32KeyFromLink(&args, "Hachievement", achId))
return false;
AchievementEntry const* achEntry = sAchievementStore.LookupEntry(achId);
if (!achEntry)
{
PSendSysMessage(LANG_ACHIEVEMENT_NOT_EXIST, achId);
SetSentErrorMessage(true);
return false;
}
LocaleConstant loc = GetSessionDbcLocale();
CompletedAchievementData const* completed = target ? target->GetAchievementMgr().GetCompleteData(achId) : NULL;
ShowAchievementListHelper(achEntry, loc, completed ? &completed->date : NULL, target);
if (AchievementCriteriaEntryList const* criteriaList = sAchievementMgr.GetAchievementCriteriaByAchievement(achEntry->ID))
{
SendSysMessage(LANG_COMMAND_ACHIEVEMENT_CRITERIA);
for (AchievementCriteriaEntryList::const_iterator itr = criteriaList->begin(); itr != criteriaList->end(); ++itr)
ShowAchievementCriteriaListHelper(*itr, achEntry, loc, target);
}
return true;
}
bool ChatHandler::HandleAchievementAddCommand(char* args)
{
char* nameStr = ExtractOptNotLastArg(&args);
Player* target;
if (!ExtractPlayerTarget(&nameStr, &target))
return false;
uint32 achId;
if (!ExtractUint32KeyFromLink(&args, "Hachievement", achId))
return false;
AchievementEntry const* achEntry = sAchievementStore.LookupEntry(achId);
if (!achEntry || achEntry->flags & ACHIEVEMENT_FLAG_COUNTER)
{
PSendSysMessage(LANG_ACHIEVEMENT_NOT_EXIST, achId);
SetSentErrorMessage(true);
return false;
}
AchievementMgr& mgr = target->GetAchievementMgr();
if (AchievementCriteriaEntryList const* criteriaList = sAchievementMgr.GetAchievementCriteriaByAchievement(achEntry->ID))
{
for (AchievementCriteriaEntryList::const_iterator itr = criteriaList->begin(); itr != criteriaList->end(); ++itr)
{
if (mgr.IsCompletedCriteria(*itr, achEntry))
continue;
uint32 maxValue = AchievementMgr::GetCriteriaProgressMaxCounter(*itr, achEntry);
if (maxValue == std::numeric_limits<uint32>::max())
maxValue = 1; // Exception for counter like achievements, set them only to 1
mgr.SetCriteriaProgress(*itr, achEntry, maxValue, AchievementMgr::PROGRESS_SET);
}
}
LocaleConstant loc = GetSessionDbcLocale();
CompletedAchievementData const* completed = target ? target->GetAchievementMgr().GetCompleteData(achId) : NULL;
ShowAchievementListHelper(achEntry, loc, completed ? &completed->date : NULL, target);
return true;
}
bool ChatHandler::HandleAchievementRemoveCommand(char* args)
{
char* nameStr = ExtractOptNotLastArg(&args);
Player* target;
if (!ExtractPlayerTarget(&nameStr, &target))
return false;
uint32 achId;
if (!ExtractUint32KeyFromLink(&args, "Hachievement", achId))
return false;
AchievementEntry const* achEntry = sAchievementStore.LookupEntry(achId);
if (!achEntry)
{
PSendSysMessage(LANG_ACHIEVEMENT_NOT_EXIST, achId);
SetSentErrorMessage(true);
return false;
}
AchievementMgr& mgr = target->GetAchievementMgr();
if (AchievementCriteriaEntryList const* criteriaList = sAchievementMgr.GetAchievementCriteriaByAchievement(achEntry->ID))
for (AchievementCriteriaEntryList::const_iterator itr = criteriaList->begin(); itr != criteriaList->end(); ++itr)
mgr.SetCriteriaProgress(*itr, achEntry, 0, AchievementMgr::PROGRESS_SET);
LocaleConstant loc = GetSessionDbcLocale();
CompletedAchievementData const* completed = target ? target->GetAchievementMgr().GetCompleteData(achId) : NULL;
ShowAchievementListHelper(achEntry, loc, completed ? &completed->date : NULL, target);
return true;
}
bool ChatHandler::HandleAchievementCriteriaAddCommand(char* args)
{
Player* target;
uint32 criId;
if (!ExtractUint32KeyFromLink(&args, "Hachievement_criteria", criId))
{
// maybe player first
char* nameStr = ExtractArg(&args);
if (!ExtractPlayerTarget(&nameStr, &target))
return false;
if (!ExtractUint32KeyFromLink(&args, "Hachievement_criteria", criId))
return false;
}
else
target = getSelectedPlayer();
AchievementCriteriaEntry const* criEntry = sAchievementCriteriaStore.LookupEntry(criId);
if (!criEntry)
{
PSendSysMessage(LANG_ACHIEVEMENT_CRITERIA_NOT_EXIST, criId);
SetSentErrorMessage(true);
return false;
}
AchievementEntry const* achEntry = sAchievementStore.LookupEntry(criEntry->referredAchievement);
if (!achEntry)
return false;
LocaleConstant loc = GetSessionDbcLocale();
uint32 maxValue = AchievementMgr::GetCriteriaProgressMaxCounter(criEntry, achEntry);
if (maxValue == std::numeric_limits<uint32>::max())
maxValue = 1; // Exception for counter like achievements, set them only to 1
AchievementMgr& mgr = target->GetAchievementMgr();
// nothing do if completed
if (mgr.IsCompletedCriteria(criEntry, achEntry))
{
ShowAchievementCriteriaListHelper(criEntry, achEntry, loc, target);
return true;
}
uint32 progress = mgr.GetCriteriaProgressCounter(criEntry);
uint32 val;
if (!ExtractOptUInt32(&args, val, maxValue ? maxValue : 1))
return false;
uint32 new_val;
if (maxValue)
new_val = progress < maxValue && maxValue - progress > val ? progress + val : maxValue;
else
{
uint32 max_int = std::numeric_limits<uint32>::max();
new_val = progress < max_int && max_int - progress > val ? progress + val : max_int;
}
mgr.SetCriteriaProgress(criEntry, achEntry, new_val, AchievementMgr::PROGRESS_SET);
ShowAchievementCriteriaListHelper(criEntry, achEntry, loc, target);
return true;
}
bool ChatHandler::HandleAchievementCriteriaRemoveCommand(char* args)
{
Player* target;
uint32 criId;
if (!ExtractUint32KeyFromLink(&args, "Hachievement_criteria", criId))
{
// maybe player first
char* nameStr = ExtractArg(&args);
if (!ExtractPlayerTarget(&nameStr, &target))
return false;
if (!ExtractUint32KeyFromLink(&args, "Hachievement_criteria", criId))
return false;
}
else
target = getSelectedPlayer();
AchievementCriteriaEntry const* criEntry = sAchievementCriteriaStore.LookupEntry(criId);
if (!criEntry)
{
PSendSysMessage(LANG_ACHIEVEMENT_CRITERIA_NOT_EXIST, criId);
SetSentErrorMessage(true);
return false;
}
AchievementEntry const* achEntry = sAchievementStore.LookupEntry(criEntry->referredAchievement);
if (!achEntry)
return false;
LocaleConstant loc = GetSessionDbcLocale();
uint32 maxValue = AchievementMgr::GetCriteriaProgressMaxCounter(criEntry, achEntry);
if (maxValue == std::numeric_limits<uint32>::max())
maxValue = 1; // Exception for counter like achievements, set them only to 1
AchievementMgr& mgr = target->GetAchievementMgr();
uint32 progress = mgr.GetCriteriaProgressCounter(criEntry);
// nothing do if not started
if (progress == 0)
{
ShowAchievementCriteriaListHelper(criEntry, achEntry, loc, target);
return true;
}
uint32 change;
if (!ExtractOptUInt32(&args, change, maxValue ? maxValue : 1))
return false;
uint32 newval = change < progress ? progress - change : 0;
mgr.SetCriteriaProgress(criEntry, achEntry, newval, AchievementMgr::PROGRESS_SET);
ShowAchievementCriteriaListHelper(criEntry, achEntry, loc, target);
return true;
}
bool ChatHandler::HandleMaxSkillCommand(char* /*args*/)
{
Player* SelectedPlayer = getSelectedPlayer();
if (!SelectedPlayer)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
// each skills that have max skill value dependent from level seted to current level max skill value
SelectedPlayer->UpdateSkillsToMaxSkillsForLevel();
return true;
}
bool ChatHandler::HandleSetSkillCommand(char* args)
{
Player* target = getSelectedPlayer();
if (!target)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hskill:skill_id|h[name]|h|r
char* skill_p = ExtractKeyFromLink(&args, "Hskill");
if (!skill_p)
{ return false; }
int32 skill;
if (!ExtractInt32(&skill_p, skill))
{ return false; }
int32 level;
if (!ExtractInt32(&args, level))
{ return false; }
int32 maxskill;
if (!ExtractOptInt32(&args, maxskill, target->GetPureMaxSkillValue(skill)))
{ return false; }
if (skill <= 0)
{
PSendSysMessage(LANG_INVALID_SKILL_ID, skill);
SetSentErrorMessage(true);
return false;
}
SkillLineEntry const* sl = sSkillLineStore.LookupEntry(skill);
if (!sl)
{
PSendSysMessage(LANG_INVALID_SKILL_ID, skill);
SetSentErrorMessage(true);
return false;
}
std::string tNameLink = GetNameLink(target);
if (!target->GetSkillValue(skill))
{
PSendSysMessage(LANG_SET_SKILL_ERROR, tNameLink.c_str(), skill, sl->name[GetSessionDbcLocale()]);
SetSentErrorMessage(true);
return false;
}
if (level <= 0 || level > maxskill || maxskill <= 0)
{ return false; }
target->SetSkill(skill, level, maxskill);
PSendSysMessage(LANG_SET_SKILL, skill, sl->name[GetSessionDbcLocale()], tNameLink.c_str(), level, maxskill);
return true;
}
bool ChatHandler::HandleUnLearnCommand(char* args)
{
if (!*args)
{ return false; }
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
uint32 spell_id = ExtractSpellIdFromLink(&args);
if (!spell_id)
{ return false; }
bool allRanks = ExtractLiteralArg(&args, "all") != NULL;
if (!allRanks && *args) // can be fail also at syntax error
{ return false; }
Player* target = getSelectedPlayer();
if (!target)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
if (allRanks)
{ spell_id = sSpellMgr.GetFirstSpellInChain(spell_id); }
if (target->HasSpell(spell_id))
{ target->removeSpell(spell_id, false, !allRanks); }
else
{ SendSysMessage(LANG_FORGET_SPELL); }
if (GetTalentSpellCost(spell_id))
target->SendTalentsInfoData(false);
return true;
}
bool ChatHandler::HandleCooldownCommand(char* args)
{
Player* target = getSelectedPlayer();
if (!target)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
std::string tNameLink = GetNameLink(target);
if (!*args)
{
target->RemoveAllSpellCooldown();
PSendSysMessage(LANG_REMOVEALL_COOLDOWN, tNameLink.c_str());
}
else
{
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell_id = ExtractSpellIdFromLink(&args);
if (!spell_id)
{ return false; }
if (!sSpellStore.LookupEntry(spell_id))
{
PSendSysMessage(LANG_UNKNOWN_SPELL, target == m_session->GetPlayer() ? GetMangosString(LANG_YOU) : tNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
target->RemoveSpellCooldown(spell_id, true);
PSendSysMessage(LANG_REMOVE_COOLDOWN, spell_id, target == m_session->GetPlayer() ? GetMangosString(LANG_YOU) : tNameLink.c_str());
}
return true;
}
bool ChatHandler::HandleLearnAllCommand(char* /*args*/)
{
static const char* allSpellList[] =
{
"3365",
"6233",
"6247",
"6246",
"6477",
"6478",
"22810",
"8386",
"21651",
"21652",
"522",
"7266",
"8597",
"2479",
"22027",
"6603",
"5019",
"133",
"168",
"227",
"5009",
"9078",
"668",
"203",
"20599",
"20600",
"81",
"20597",
"20598",
"20864",
"1459",
"5504",
"587",
"5143",
"118",
"5505",
"597",
"604",
"1449",
"1460",
"2855",
"1008",
"475",
"5506",
"1463",
"12824",
"8437",
"990",
"5145",
"8450",
"1461",
"759",
"8494",
"8455",
"8438",
"6127",
"8416",
"6129",
"8451",
"8495",
"8439",
"3552",
"8417",
"10138",
"12825",
"10169",
"10156",
"10144",
"10191",
"10201",
"10211",
"10053",
"10173",
"10139",
"10145",
"10192",
"10170",
"10202",
"10054",
"10174",
"10193",
"12826",
"2136",
"143",
"145",
"2137",
"2120",
"3140",
"543",
"2138",
"2948",
"8400",
"2121",
"8444",
"8412",
"8457",
"8401",
"8422",
"8445",
"8402",
"8413",
"8458",
"8423",
"8446",
"10148",
"10197",
"10205",
"10149",
"10215",
"10223",
"10206",
"10199",
"10150",
"10216",
"10207",
"10225",
"10151",
"116",
"205",
"7300",
"122",
"837",
"10",
"7301",
"7322",
"6143",
"120",
"865",
"8406",
"6141",
"7302",
"8461",
"8407",
"8492",
"8427",
"8408",
"6131",
"7320",
"10159",
"8462",
"10185",
"10179",
"10160",
"10180",
"10219",
"10186",
"10177",
"10230",
"10181",
"10161",
"10187",
"10220",
"2018",
"2663",
"12260",
"2660",
"3115",
"3326",
"2665",
"3116",
"2738",
"3293",
"2661",
"3319",
"2662",
"9983",
"8880",
"2737",
"2739",
"7408",
"3320",
"2666",
"3323",
"3324",
"3294",
"22723",
"23219",
"23220",
"23221",
"23228",
"23338",
"10788",
"10790",
"5611",
"5016",
"5609",
"2060",
"10963",
"10964",
"10965",
"22593",
"22594",
"596",
"996",
"499",
"768",
"17002",
"1448",
"1082",
"16979",
"1079",
"5215",
"20484",
"5221",
"15590",
"17007",
"6795",
"6807",
"5487",
"1446",
"1066",
"5421",
"3139",
"779",
"6811",
"6808",
"1445",
"5216",
"1737",
"5222",
"5217",
"1432",
"6812",
"9492",
"5210",
"3030",
"1441",
"783",
"6801",
"20739",
"8944",
"9491",
"22569",
"5226",
"6786",
"1433",
"8973",
"1828",
"9495",
"9006",
"6794",
"8993",
"5203",
"16914",
"6784",
"9635",
"22830",
"20722",
"9748",
"6790",
"9753",
"9493",
"9752",
"9831",
"9825",
"9822",
"5204",
"5401",
"22831",
"6793",
"9845",
"17401",
"9882",
"9868",
"20749",
"9893",
"9899",
"9895",
"9832",
"9902",
"9909",
"22832",
"9828",
"9851",
"9883",
"9869",
"17406",
"17402",
"9914",
"20750",
"9897",
"9848",
"3127",
"107",
"204",
"9116",
"2457",
"78",
"18848",
"331",
"403",
"2098",
"1752",
"11278",
"11288",
"11284",
"6461",
"2344",
"2345",
"6463",
"2346",
"2352",
"775",
"1434",
"1612",
"71",
"2468",
"2458",
"2467",
"7164",
"7178",
"7367",
"7376",
"7381",
"21156",
"5209",
"3029",
"5201",
"9849",
"9850",
"20719",
"22568",
"22827",
"22828",
"22829",
"6809",
"8972",
"9005",
"9823",
"9827",
"6783",
"9913",
"6785",
"6787",
"9866",
"9867",
"9894",
"9896",
"6800",
"8992",
"9829",
"9830",
"780",
"769",
"6749",
"6750",
"9755",
"9754",
"9908",
"20745",
"20742",
"20747",
"20748",
"9746",
"9745",
"9880",
"9881",
"5391",
"842",
"3025",
"3031",
"3287",
"3329",
"1945",
"3559",
"4933",
"4934",
"4935",
"4936",
"5142",
"5390",
"5392",
"5404",
"5420",
"6405",
"7293",
"7965",
"8041",
"8153",
"9033",
"9034",
//"9036", problems with ghost state
"16421",
"21653",
"22660",
"5225",
"9846",
"2426",
"5916",
"6634",
//"6718", phasing stealth, annoying for learn all case.
"6719",
"8822",
"9591",
"9590",
"10032",
"17746",
"17747",
"8203",
"11392",
"12495",
"16380",
"23452",
"4079",
"4996",
"4997",
"4998",
"4999",
"5000",
"6348",
"6349",
"6481",
"6482",
"6483",
"6484",
"11362",
"11410",
"11409",
"12510",
"12509",
"12885",
"13142",
"21463",
"23460",
"11421",
"11416",
"11418",
"1851",
"10059",
"11423",
"11417",
"11422",
"11419",
"11424",
"11420",
"27",
"31",
"33",
"34",
"35",
"15125",
"21127",
"22950",
"1180",
"201",
"12593",
"12842",
"16770",
"6057",
"12051",
"18468",
"12606",
"12605",
"18466",
"12502",
"12043",
"15060",
"12042",
"12341",
"12848",
"12344",
"12353",
"18460",
"11366",
"12350",
"12352",
"13043",
"11368",
"11113",
"12400",
"11129",
"16766",
"12573",
"15053",
"12580",
"12475",
"12472",
"12953",
"12488",
"11189",
"12985",
"12519",
"16758",
"11958",
"12490",
"11426",
"3565",
"3562",
"18960",
"3567",
"3561",
"3566",
"3563",
"1953",
"2139",
"12505",
"13018",
"12522",
"12523",
"5146",
"5144",
"5148",
"8419",
"8418",
"10213",
"10212",
"10157",
"12524",
"13019",
"12525",
"13020",
"12526",
"13021",
"18809",
"13031",
"13032",
"13033",
"4036",
"3920",
"3919",
"3918",
"7430",
"3922",
"3923",
"7411",
"7418",
"7421",
"13262",
"7412",
"7415",
"7413",
"7416",
"13920",
"13921",
"7745",
"7779",
"7428",
"7457",
"7857",
"7748",
"7426",
"13421",
"7454",
"13378",
"7788",
"14807",
"14293",
"7795",
"6296",
"20608",
"755",
"444",
"427",
"428",
"442",
"447",
"3578",
"3581",
"19027",
"3580",
"665",
"3579",
"3577",
"6755",
"3576",
"2575",
"2577",
"2578",
"2579",
"2580",
"2656",
"2657",
"2576",
"3564",
"10248",
"8388",
"2659",
"14891",
"3308",
"3307",
"10097",
"2658",
"3569",
"16153",
"3304",
"10098",
"4037",
"3929",
"3931",
"3926",
"3924",
"3930",
"3977",
"3925",
"136",
"228",
"5487",
"43",
"202",
"0"
};
int loop = 0;
while (strcmp(allSpellList[loop], "0"))
{
uint32 spell = atol((char*)allSpellList[loop++]);
if (m_session->GetPlayer()->HasSpell(spell))
{ continue; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, m_session->GetPlayer()))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
continue;
}
m_session->GetPlayer()->learnSpell(spell, false);
}
SendSysMessage(LANG_COMMAND_LEARN_MANY_SPELLS);
return true;
}
bool ChatHandler::HandleLearnAllGMCommand(char* /*args*/)
{
static const char* gmSpellList[] =
{
"24347", // Become A Fish, No Breath Bar
"35132", // Visual Boom
"38488", // Attack 4000-8000 AOE
"38795", // Attack 2000 AOE + Slow Down 90%
"15712", // Attack 200
"1852", // GM Spell Silence
"31899", // Kill
"31924", // Kill
"29878", // Kill My Self
"26644", // More Kill
"28550", // Invisible 24
"23452", // Invisible + Target
"0"
};
uint16 gmSpellIter = 0;
while (strcmp(gmSpellList[gmSpellIter], "0"))
{
uint32 spell = atol((char*)gmSpellList[gmSpellIter++]);
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, m_session->GetPlayer()))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
continue;
}
m_session->GetPlayer()->learnSpell(spell, false);
}
SendSysMessage(LANG_LEARNING_GM_SKILLS);
return true;
}
bool ChatHandler::HandleLearnAllMyClassCommand(char* /*args*/)
{
HandleLearnAllMySpellsCommand((char*)"");
HandleLearnAllMyTalentsCommand((char*)"");
return true;
}
bool ChatHandler::HandleLearnAllMySpellsCommand(char* /*args*/)
{
Player* player = m_session->GetPlayer();
ChrClassesEntry const* clsEntry = sChrClassesStore.LookupEntry(player->getClass());
if (!clsEntry)
{ return true; }
uint32 family = clsEntry->spellfamily;
for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); ++i)
{
SkillLineAbilityEntry const* entry = sSkillLineAbilityStore.LookupEntry(i);
if (!entry)
{ continue; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(entry->spellId);
if (!spellInfo)
{ continue; }
// skip server-side/triggered spells
if (spellInfo->spellLevel == 0)
{ continue; }
// skip wrong class/race skills
if (!player->IsSpellFitByClassAndRace(spellInfo->Id))
{ continue; }
// skip other spell families
if (spellInfo->SpellFamilyName != family)
{ continue; }
// skip spells with first rank learned as talent (and all talents then also)
uint32 first_rank = sSpellMgr.GetFirstSpellInChain(spellInfo->Id);
if (GetTalentSpellCost(first_rank) > 0)
{ continue; }
// skip broken spells
if (!SpellMgr::IsSpellValid(spellInfo, player, false))
{ continue; }
player->learnSpell(spellInfo->Id, false);
}
SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
return true;
}
bool ChatHandler::HandleLearnAllMyTalentsCommand(char* /*args*/)
{
Player* player = m_session->GetPlayer();
uint32 classMask = player->getClassMask();
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
if (!talentInfo)
{ continue; }
TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
if (!talentTabInfo)
{ continue; }
if ((classMask & talentTabInfo->ClassMask) == 0)
{ continue; }
// search highest talent rank
uint32 spellid = 0;
for (int rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
{
if (talentInfo->RankID[rank] != 0)
{
spellid = talentInfo->RankID[rank];
break;
}
}
if (!spellid) // ??? none spells in talent
{ continue; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid);
if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, player, false))
{ continue; }
// learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
player->learnSpellHighRank(spellid);
}
player->SendTalentsInfoData(false);
SendSysMessage(LANG_COMMAND_LEARN_CLASS_TALENTS);
return true;
}
bool ChatHandler::HandleLearnAllMyPetTalentsCommand(char* /*args*/)
{
Player* player = m_session->GetPlayer();
Pet* pet = player->GetPet();
if (!pet)
{
SendSysMessage(LANG_NO_PET_FOUND);
SetSentErrorMessage(true);
return false;
}
CreatureInfo const* ci = pet->GetCreatureInfo();
if (!ci)
{
SendSysMessage(LANG_WRONG_PET_TYPE);
SetSentErrorMessage(true);
return false;
}
CreatureFamilyEntry const* pet_family = sCreatureFamilyStore.LookupEntry(ci->Family);
if (!pet_family)
{
SendSysMessage(LANG_WRONG_PET_TYPE);
SetSentErrorMessage(true);
return false;
}
if (pet_family->petTalentType < 0) // not hunter pet
{
SendSysMessage(LANG_WRONG_PET_TYPE);
SetSentErrorMessage(true);
return false;
}
for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
{
TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
if (!talentInfo)
continue;
TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
if (!talentTabInfo)
continue;
// prevent learn talent for different family (cheating)
if (((1 << pet_family->petTalentType) & talentTabInfo->petTalentMask) == 0)
continue;
// search highest talent rank
uint32 spellid = 0;
for (int rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
{
if (talentInfo->RankID[rank] != 0)
{
spellid = talentInfo->RankID[rank];
break;
}
}
if (!spellid) // ??? none spells in talent
continue;
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid);
if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, player, false))
continue;
// learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
pet->learnSpellHighRank(spellid);
}
player->SendTalentsInfoData(true);
SendSysMessage(LANG_COMMAND_LEARN_PET_TALENTS);
return true;
}
bool ChatHandler::HandleLearnAllLangCommand(char* /*args*/)
{
Player* player = m_session->GetPlayer();
// skipping UNIVERSAL language (0)
for (int i = 1; i < LANGUAGES_COUNT; ++i)
{ player->learnSpell(lang_description[i].spell_id, false); }
SendSysMessage(LANG_COMMAND_LEARN_ALL_LANG);
return true;
}
bool ChatHandler::HandleLearnAllDefaultCommand(char* args)
{
Player* target;
if (!ExtractPlayerTarget(&args, &target))
{ return false; }
target->learnDefaultSpells();
target->learnQuestRewardedSpells();
PSendSysMessage(LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST, GetNameLink(target).c_str());
return true;
}
bool ChatHandler::HandleLearnCommand(char* args)
{
Player* player = m_session->GetPlayer();
Player* targetPlayer = getSelectedPlayer();
if (!targetPlayer)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell || !sSpellStore.LookupEntry(spell))
{ return false; }
bool allRanks = ExtractLiteralArg(&args, "all") != NULL;
if (!allRanks && *args) // can be fail also at syntax error
{ return false; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, player))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
SetSentErrorMessage(true);
return false;
}
if (!allRanks && targetPlayer->HasSpell(spell))
{
if (targetPlayer == player)
{ SendSysMessage(LANG_YOU_KNOWN_SPELL); }
else
PSendSysMessage(LANG_TARGET_KNOWN_SPELL, GetNameLink(targetPlayer).c_str());
SetSentErrorMessage(true);
return false;
}
if (allRanks)
{ targetPlayer->learnSpellHighRank(spell); }
else
{ targetPlayer->learnSpell(spell, false); }
uint32 first_spell = sSpellMgr.GetFirstSpellInChain(spell);
if (GetTalentSpellCost(first_spell))
targetPlayer->SendTalentsInfoData(false);
return true;
}
bool ChatHandler::HandleAddItemCommand(char* args)
{
char* cId = ExtractKeyFromLink(&args, "Hitem");
if (!cId)
{ return false; }
uint32 itemId = 0;
if (!ExtractUInt32(&cId, itemId)) // [name] manual form
{
std::string itemName = cId;
WorldDatabase.escape_string(itemName);
QueryResult* result = WorldDatabase.PQuery("SELECT entry FROM item_template WHERE name = '%s'", itemName.c_str());
if (!result)
{
PSendSysMessage(LANG_COMMAND_COULDNOTFIND, cId);
SetSentErrorMessage(true);
return false;
}
itemId = result->Fetch()->GetUInt16();
delete result;
}
int32 count;
if (!ExtractOptInt32(&args, count, 1))
{ return false; }
Player* pl = m_session->GetPlayer();
Player* plTarget = getSelectedPlayer();
if (!plTarget)
{ plTarget = pl; }
DETAIL_LOG(GetMangosString(LANG_ADDITEM), itemId, count);
ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(itemId);
if (!pProto)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, itemId);
SetSentErrorMessage(true);
return false;
}
// Subtract
if (count < 0)
{
plTarget->DestroyItemCount(itemId, -count, true, false);
PSendSysMessage(LANG_REMOVEITEM, itemId, -count, GetNameLink(plTarget).c_str());
return true;
}
// Adding items
uint32 noSpaceForCount = 0;
// check space and find places
ItemPosCountVec dest;
uint8 msg = plTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemId, count, &noSpaceForCount);
if (msg != EQUIP_ERR_OK) // convert to possible store amount
{ count -= noSpaceForCount; }
if (count == 0 || dest.empty()) // can't add any
{
PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
SetSentErrorMessage(true);
return false;
}
Item* item = plTarget->StoreNewItem(dest, itemId, true, Item::GenerateItemRandomPropertyId(itemId));
// remove binding (let GM give it to another player later)
if (pl == plTarget)
for (ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); ++itr)
if (Item* item1 = pl->GetItemByPos(itr->pos))
{ item1->SetBinding(false); }
if (count > 0 && item)
{
pl->SendNewItem(item, count, false, true);
if (pl != plTarget)
{ plTarget->SendNewItem(item, count, true, false); }
}
if (noSpaceForCount > 0)
{ PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount); }
return true;
}
bool ChatHandler::HandleAddItemSetCommand(char* args)
{
uint32 itemsetId;
if (!ExtractUint32KeyFromLink(&args, "Hitemset", itemsetId))
{ return false; }
// prevent generation all items with itemset field value '0'
if (itemsetId == 0)
{
PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, itemsetId);
SetSentErrorMessage(true);
return false;
}
Player* pl = m_session->GetPlayer();
Player* plTarget = getSelectedPlayer();
if (!plTarget)
{ plTarget = pl; }
DETAIL_LOG(GetMangosString(LANG_ADDITEMSET), itemsetId);
bool found = false;
for (uint32 id = 0; id < sItemStorage.GetMaxEntry(); ++id)
{
ItemPrototype const* pProto = sItemStorage.LookupEntry<ItemPrototype>(id);
if (!pProto)
{ continue; }
if (pProto->ItemSet == itemsetId)
{
found = true;
ItemPosCountVec dest;
InventoryResult msg = plTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, pProto->ItemId, 1);
if (msg == EQUIP_ERR_OK)
{
Item* item = plTarget->StoreNewItem(dest, pProto->ItemId, true);
// remove binding (let GM give it to another player later)
if (pl == plTarget)
{ item->SetBinding(false); }
pl->SendNewItem(item, 1, false, true);
if (pl != plTarget)
{ plTarget->SendNewItem(item, 1, true, false); }
}
else
{
pl->SendEquipError(msg, NULL, NULL, pProto->ItemId);
PSendSysMessage(LANG_ITEM_CANNOT_CREATE, pProto->ItemId, 1);
}
}
}
if (!found)
{
PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, itemsetId);
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandleListItemCommand(char* args)
{
uint32 item_id;
if (!ExtractUint32KeyFromLink(&args, "Hitem", item_id))
{ return false; }
if (!item_id)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
ItemPrototype const* itemProto = ObjectMgr::GetItemPrototype(item_id);
if (!itemProto)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
uint32 count;
if (!ExtractOptUInt32(&args, count, 10))
{ return false; }
QueryResult* result;
// inventory case
uint32 inv_count = 0;
result = CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM character_inventory WHERE item_template='%u'", item_id);
if (result)
{
inv_count = (*result)[0].GetUInt32();
delete result;
}
result = CharacterDatabase.PQuery(
// 0 1 2 3 4 5
"SELECT ci.item, cibag.slot AS bag, ci.slot, ci.guid, characters.account,characters.name "
"FROM character_inventory AS ci LEFT JOIN character_inventory AS cibag ON (cibag.item=ci.bag),characters "
"WHERE ci.item_template='%u' AND ci.guid = characters.guid LIMIT %u ",
item_id, uint32(count));
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 item_guid = fields[0].GetUInt32();
uint32 item_bag = fields[1].GetUInt32();
uint32 item_slot = fields[2].GetUInt32();
uint32 owner_guid = fields[3].GetUInt32();
uint32 owner_acc = fields[4].GetUInt32();
std::string owner_name = fields[5].GetCppString();
char const* item_pos = 0;
if (Player::IsEquipmentPos(item_bag, item_slot))
{ item_pos = "[equipped]"; }
else if (Player::IsInventoryPos(item_bag, item_slot))
{ item_pos = "[in inventory]"; }
else if (Player::IsBankPos(item_bag, item_slot))
{ item_pos = "[in bank]"; }
else
{ item_pos = ""; }
PSendSysMessage(LANG_ITEMLIST_SLOT,
item_guid, owner_name.c_str(), owner_guid, owner_acc, item_pos);
}
while (result->NextRow());
uint32 res_count = uint32(result->GetRowCount());
delete result;
if (count > res_count)
{ count -= res_count; }
else if (count)
{ count = 0; }
}
// mail case
uint32 mail_count = 0;
result = CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM mail_items WHERE item_template='%u'", item_id);
if (result)
{
mail_count = (*result)[0].GetUInt32();
delete result;
}
if (count > 0)
{
result = CharacterDatabase.PQuery(
// 0 1 2 3 4 5 6
"SELECT mail_items.item_guid, mail.sender, mail.receiver, char_s.account, char_s.name, char_r.account, char_r.name "
"FROM mail,mail_items,characters as char_s,characters as char_r "
"WHERE mail_items.item_template='%u' AND char_s.guid = mail.sender AND char_r.guid = mail.receiver AND mail.id=mail_items.mail_id LIMIT %u",
item_id, uint32(count));
}
else
{ result = NULL; }
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 item_guid = fields[0].GetUInt32();
uint32 item_s = fields[1].GetUInt32();
uint32 item_r = fields[2].GetUInt32();
uint32 item_s_acc = fields[3].GetUInt32();
std::string item_s_name = fields[4].GetCppString();
uint32 item_r_acc = fields[5].GetUInt32();
std::string item_r_name = fields[6].GetCppString();
char const* item_pos = "[in mail]";
PSendSysMessage(LANG_ITEMLIST_MAIL,
item_guid, item_s_name.c_str(), item_s, item_s_acc, item_r_name.c_str(), item_r, item_r_acc, item_pos);
}
while (result->NextRow());
uint32 res_count = uint32(result->GetRowCount());
delete result;
if (count > res_count)
{ count -= res_count; }
else if (count)
{ count = 0; }
}
// auction case
uint32 auc_count = 0;
result = CharacterDatabase.PQuery("SELECT COUNT(item_template) FROM auction WHERE item_template='%u'", item_id);
if (result)
{
auc_count = (*result)[0].GetUInt32();
delete result;
}
if (count > 0)
{
result = CharacterDatabase.PQuery(
// 0 1 2 3
"SELECT auction.itemguid, auction.itemowner, characters.account, characters.name "
"FROM auction,characters WHERE auction.item_template='%u' AND characters.guid = auction.itemowner LIMIT %u",
item_id, uint32(count));
}
else
{ result = NULL; }
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 item_guid = fields[0].GetUInt32();
uint32 owner = fields[1].GetUInt32();
uint32 owner_acc = fields[2].GetUInt32();
std::string owner_name = fields[3].GetCppString();
char const* item_pos = "[in auction]";
PSendSysMessage(LANG_ITEMLIST_AUCTION, item_guid, owner_name.c_str(), owner, owner_acc, item_pos);
}
while (result->NextRow());
delete result;
}
// guild bank case
uint32 guild_count = 0;
result = CharacterDatabase.PQuery("SELECT COUNT(item_entry) FROM guild_bank_item WHERE item_entry='%u'", item_id);
if (result)
{
guild_count = (*result)[0].GetUInt32();
delete result;
}
result = CharacterDatabase.PQuery(
// 0 1 2
"SELECT gi.item_guid, gi.guildid, guild.name "
"FROM guild_bank_item AS gi, guild WHERE gi.item_entry='%u' AND gi.guildid = guild.guildid LIMIT %u ",
item_id, uint32(count));
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 item_guid = fields[0].GetUInt32();
uint32 guild_guid = fields[1].GetUInt32();
std::string guild_name = fields[2].GetCppString();
char const* item_pos = "[in guild bank]";
PSendSysMessage(LANG_ITEMLIST_GUILD, item_guid, guild_name.c_str(), guild_guid, item_pos);
}
while (result->NextRow());
uint32 res_count = uint32(result->GetRowCount());
delete result;
if (count > res_count)
count -= res_count;
else if (count)
count = 0;
}
if (inv_count + mail_count + auc_count + guild_count == 0)
{
SendSysMessage(LANG_COMMAND_NOITEMFOUND);
SetSentErrorMessage(true);
return false;
}
PSendSysMessage(LANG_COMMAND_LISTITEMMESSAGE, item_id, inv_count + mail_count + auc_count + guild_count, inv_count, mail_count, auc_count, guild_count);
return true;
}
bool ChatHandler::HandleListObjectCommand(char* args)
{
// number or [name] Shift-click form |color|Hgameobject_entry:go_id|h[name]|h|r
uint32 go_id;
if (!ExtractUint32KeyFromLink(&args, "Hgameobject_entry", go_id))
{ return false; }
if (!go_id)
{
PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
SetSentErrorMessage(true);
return false;
}
GameObjectInfo const* gInfo = ObjectMgr::GetGameObjectInfo(go_id);
if (!gInfo)
{
PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
SetSentErrorMessage(true);
return false;
}
uint32 count;
if (!ExtractOptUInt32(&args, count, 10))
{ return false; }
QueryResult* result;
uint32 obj_count = 0;
result = WorldDatabase.PQuery("SELECT COUNT(guid) FROM gameobject WHERE id='%u'", go_id);
if (result)
{
obj_count = (*result)[0].GetUInt32();
delete result;
}
if (m_session)
{
Player* pl = m_session->GetPlayer();
result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), go_id, uint32(count));
}
else
result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM gameobject WHERE id = '%u' LIMIT %u",
go_id, uint32(count));
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 guid = fields[0].GetUInt32();
float x = fields[1].GetFloat();
float y = fields[2].GetFloat();
float z = fields[3].GetFloat();
int mapid = fields[4].GetUInt16();
if (m_session)
{ PSendSysMessage(LANG_GO_LIST_CHAT, guid, PrepareStringNpcOrGoSpawnInformation<GameObject>(guid).c_str(), guid, gInfo->name, x, y, z, mapid); }
else
{ PSendSysMessage(LANG_GO_LIST_CONSOLE, guid, PrepareStringNpcOrGoSpawnInformation<GameObject>(guid).c_str(), gInfo->name, x, y, z, mapid); }
}
while (result->NextRow());
delete result;
}
PSendSysMessage(LANG_COMMAND_LISTOBJMESSAGE, go_id, obj_count);
return true;
}
bool ChatHandler::HandleListCreatureCommand(char* args)
{
// number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
uint32 cr_id;
if (!ExtractUint32KeyFromLink(&args, "Hcreature_entry", cr_id))
{ return false; }
if (!cr_id)
{
PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
SetSentErrorMessage(true);
return false;
}
CreatureInfo const* cInfo = ObjectMgr::GetCreatureTemplate(cr_id);
if (!cInfo)
{
PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
SetSentErrorMessage(true);
return false;
}
uint32 count;
if (!ExtractOptUInt32(&args, count, 10))
{ return false; }
QueryResult* result;
uint32 cr_count = 0;
result = WorldDatabase.PQuery("SELECT COUNT(guid) FROM creature WHERE id='%u'", cr_id);
if (result)
{
cr_count = (*result)[0].GetUInt32();
delete result;
}
if (m_session)
{
Player* pl = m_session->GetPlayer();
result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM creature WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), cr_id, uint32(count));
}
else
result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM creature WHERE id = '%u' LIMIT %u",
cr_id, uint32(count));
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 guid = fields[0].GetUInt32();
float x = fields[1].GetFloat();
float y = fields[2].GetFloat();
float z = fields[3].GetFloat();
int mapid = fields[4].GetUInt16();
if (m_session)
{ PSendSysMessage(LANG_CREATURE_LIST_CHAT, guid, PrepareStringNpcOrGoSpawnInformation<Creature>(guid).c_str(), guid, cInfo->Name, x, y, z, mapid); }
else
{ PSendSysMessage(LANG_CREATURE_LIST_CONSOLE, guid, PrepareStringNpcOrGoSpawnInformation<Creature>(guid).c_str(), cInfo->Name, x, y, z, mapid); }
}
while (result->NextRow());
delete result;
}
PSendSysMessage(LANG_COMMAND_LISTCREATUREMESSAGE, cr_id, cr_count);
return true;
}
void ChatHandler::ShowItemListHelper(uint32 itemId, int loc_idx, Player* target /*=NULL*/)
{
ItemPrototype const* itemProto = sItemStorage.LookupEntry<ItemPrototype >(itemId);
if (!itemProto)
{ return; }
std::string name = itemProto->Name1;
sObjectMgr.GetItemLocaleStrings(itemProto->ItemId, loc_idx, &name);
char const* usableStr = "";
if (target)
{
if (target->CanUseItem(itemProto))
{ usableStr = GetMangosString(LANG_COMMAND_ITEM_USABLE); }
}
if (m_session)
{ PSendSysMessage(LANG_ITEM_LIST_CHAT, itemId, itemId, name.c_str(), usableStr); }
else
{ PSendSysMessage(LANG_ITEM_LIST_CONSOLE, itemId, name.c_str(), usableStr); }
}
bool ChatHandler::HandleLookupItemCommand(char* args)
{
if (!*args)
{ return false; }
std::string namepart = args;
std::wstring wnamepart;
// converting string that we try to find to lower case
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
wstrToLower(wnamepart);
Player* pl = m_session ? m_session->GetPlayer() : NULL;
uint32 counter = 0;
// Search in `item_template`
for (uint32 id = 0; id < sItemStorage.GetMaxEntry(); ++id)
{
ItemPrototype const* pProto = sItemStorage.LookupEntry<ItemPrototype >(id);
if (!pProto)
{ continue; }
int loc_idx = GetSessionDbLocaleIndex();
std::string name; // "" for let later only single time check default locale name directly
sObjectMgr.GetItemLocaleStrings(id, loc_idx, &name);
if ((name.empty() || !Utf8FitTo(name, wnamepart)) && !Utf8FitTo(pProto->Name1, wnamepart))
{ continue; }
ShowItemListHelper(id, loc_idx, pl);
++counter;
}
if (counter == 0)
{ SendSysMessage(LANG_COMMAND_NOITEMFOUND); }
return true;
}
bool ChatHandler::HandleLookupItemSetCommand(char* args)
{
if (!*args)
{ return false; }
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
// converting string that we try to find to lower case
wstrToLower(wnamepart);
uint32 counter = 0; // Counter for figure out that we found smth.
// Search in ItemSet.dbc
for (uint32 id = 0; id < sItemSetStore.GetNumRows(); ++id)
{
ItemSetEntry const* set = sItemSetStore.LookupEntry(id);
if (set)
{
int loc = GetSessionDbcLocale();
std::string name = set->name[loc];
if (name.empty())
{ continue; }
if (!Utf8FitTo(name, wnamepart))
{
loc = 0;
for (; loc < MAX_LOCALE; ++loc)
{
if (loc == GetSessionDbcLocale())
{ continue; }
name = set->name[loc];
if (name.empty())
{ continue; }
if (Utf8FitTo(name, wnamepart))
{ break; }
}
}
if (loc < MAX_LOCALE)
{
// send item set in "id - [namedlink locale]" format
if (m_session)
{ PSendSysMessage(LANG_ITEMSET_LIST_CHAT, id, id, name.c_str(), localeNames[loc]); }
else
{ PSendSysMessage(LANG_ITEMSET_LIST_CONSOLE, id, name.c_str(), localeNames[loc]); }
++counter;
}
}
}
if (counter == 0) // if counter == 0 then we found nth
{ SendSysMessage(LANG_COMMAND_NOITEMSETFOUND); }
return true;
}
bool ChatHandler::HandleLookupSkillCommand(char* args)
{
if (!*args)
{ return false; }
// can be NULL in console call
Player* target = getSelectedPlayer();
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
// converting string that we try to find to lower case
wstrToLower(wnamepart);
uint32 counter = 0; // Counter for figure out that we found smth.
// Search in SkillLine.dbc
for (uint32 id = 0; id < sSkillLineStore.GetNumRows(); ++id)
{
SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(id);
if (skillInfo)
{
int loc = GetSessionDbcLocale();
std::string name = skillInfo->name[loc];
if (name.empty())
{ continue; }
if (!Utf8FitTo(name, wnamepart))
{
loc = 0;
for (; loc < MAX_LOCALE; ++loc)
{
if (loc == GetSessionDbcLocale())
{ continue; }
name = skillInfo->name[loc];
if (name.empty())
{ continue; }
if (Utf8FitTo(name, wnamepart))
{ break; }
}
}
if (loc < MAX_LOCALE)
{
char valStr[50] = "";
char const* knownStr = "";
if (target && target->HasSkill(id))
{
knownStr = GetMangosString(LANG_KNOWN);
uint32 curValue = target->GetPureSkillValue(id);
uint32 maxValue = target->GetPureMaxSkillValue(id);
uint32 permValue = target->GetSkillPermBonusValue(id);
uint32 tempValue = target->GetSkillTempBonusValue(id);
char const* valFormat = GetMangosString(LANG_SKILL_VALUES);
snprintf(valStr, 50, valFormat, curValue, maxValue, permValue, tempValue);
}
// send skill in "id - [namedlink locale]" format
if (m_session)
{ PSendSysMessage(LANG_SKILL_LIST_CHAT, id, id, name.c_str(), localeNames[loc], knownStr, valStr); }
else
{ PSendSysMessage(LANG_SKILL_LIST_CONSOLE, id, name.c_str(), localeNames[loc], knownStr, valStr); }
++counter;
}
}
}
if (counter == 0) // if counter == 0 then we found nth
{ SendSysMessage(LANG_COMMAND_NOSKILLFOUND); }
return true;
}
void ChatHandler::ShowSpellListHelper(Player* target, SpellEntry const* spellInfo, LocaleConstant loc)
{
uint32 id = spellInfo->Id;
bool known = target && target->HasSpell(id);
bool learn = (spellInfo->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_LEARN_SPELL);
uint32 talentCost = GetTalentSpellCost(id);
bool talent = (talentCost > 0);
bool passive = IsPassiveSpell(spellInfo);
bool active = target && target->HasAura(id);
// unit32 used to prevent interpreting uint8 as char at output
// find rank of learned spell for learning spell, or talent rank
uint32 rank = talentCost ? talentCost : sSpellMgr.GetSpellRank(learn ? spellInfo->EffectTriggerSpell[EFFECT_INDEX_0] : id);
// send spell in "id - [name, rank N] [talent] [passive] [learn] [known]" format
std::ostringstream ss;
if (m_session)
{ ss << id << " - |cffffffff|Hspell:" << id << "|h[" << spellInfo->SpellName[loc]; }
else
{ ss << id << " - " << spellInfo->SpellName[loc]; }
// include rank in link name
if (rank)
{ ss << GetMangosString(LANG_SPELL_RANK) << rank; }
if (m_session)
{ ss << " " << localeNames[loc] << "]|h|r"; }
else
{ ss << " " << localeNames[loc]; }
if (talent)
{ ss << GetMangosString(LANG_TALENT); }
if (passive)
{ ss << GetMangosString(LANG_PASSIVE); }
if (learn)
{ ss << GetMangosString(LANG_LEARN); }
if (known)
{ ss << GetMangosString(LANG_KNOWN); }
if (active)
{ ss << GetMangosString(LANG_ACTIVE); }
SendSysMessage(ss.str().c_str());
}
bool ChatHandler::HandleLookupSpellCommand(char* args)
{
if (!*args)
{ return false; }
// can be NULL at console call
Player* target = getSelectedPlayer();
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
// converting string that we try to find to lower case
wstrToLower(wnamepart);
uint32 counter = 0; // Counter for figure out that we found smth.
// Search in Spell.dbc
for (uint32 id = 0; id < sSpellStore.GetNumRows(); ++id)
{
SpellEntry const* spellInfo = sSpellStore.LookupEntry(id);
if (spellInfo)
{
int loc = GetSessionDbcLocale();
std::string name = spellInfo->SpellName[loc];
if (name.empty())
{ continue; }
if (!Utf8FitTo(name, wnamepart))
{
loc = 0;
for (; loc < MAX_LOCALE; ++loc)
{
if (loc == GetSessionDbcLocale())
{ continue; }
name = spellInfo->SpellName[loc];
if (name.empty())
{ continue; }
if (Utf8FitTo(name, wnamepart))
{ break; }
}
}
if (loc < MAX_LOCALE)
{
ShowSpellListHelper(target, spellInfo, LocaleConstant(loc));
++counter;
}
}
}
if (counter == 0) // if counter == 0 then we found nth
{ SendSysMessage(LANG_COMMAND_NOSPELLFOUND); }
return true;
}
void ChatHandler::ShowQuestListHelper(uint32 questId, int32 loc_idx, Player* target /*= NULL*/)
{
Quest const* qinfo = sObjectMgr.GetQuestTemplate(questId);
if (!qinfo)
{ return; }
std::string title = qinfo->GetTitle();
sObjectMgr.GetQuestLocaleStrings(questId, loc_idx, &title);
char const* statusStr = "";
if (target)
{
QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());
if (status == QUEST_STATUS_COMPLETE)
{
if (target->GetQuestRewardStatus(qinfo->GetQuestId()))
{ statusStr = GetMangosString(LANG_COMMAND_QUEST_REWARDED); }
else
{ statusStr = GetMangosString(LANG_COMMAND_QUEST_COMPLETE); }
}
else if (status == QUEST_STATUS_INCOMPLETE)
{ statusStr = GetMangosString(LANG_COMMAND_QUEST_ACTIVE); }
}
if (m_session)
{ PSendSysMessage(LANG_QUEST_LIST_CHAT, qinfo->GetQuestId(), qinfo->GetQuestId(), qinfo->GetQuestLevel(), title.c_str(), statusStr); }
else
{ PSendSysMessage(LANG_QUEST_LIST_CONSOLE, qinfo->GetQuestId(), title.c_str(), statusStr); }
}
bool ChatHandler::HandleLookupQuestCommand(char* args)
{
if (!*args)
{ return false; }
// can be NULL at console call
Player* target = getSelectedPlayer();
std::string namepart = args;
std::wstring wnamepart;
// converting string that we try to find to lower case
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
wstrToLower(wnamepart);
uint32 counter = 0 ;
int loc_idx = GetSessionDbLocaleIndex();
ObjectMgr::QuestMap const& qTemplates = sObjectMgr.GetQuestTemplates();
for (ObjectMgr::QuestMap::const_iterator iter = qTemplates.begin(); iter != qTemplates.end(); ++iter)
{
Quest* qinfo = iter->second;
std::string title; // "" for avoid repeating check default locale
sObjectMgr.GetQuestLocaleStrings(qinfo->GetQuestId(), loc_idx, &title);
if ((title.empty() || !Utf8FitTo(title, wnamepart)) && !Utf8FitTo(qinfo->GetTitle(), wnamepart))
{ continue; }
ShowQuestListHelper(qinfo->GetQuestId(), loc_idx, target);
++counter;
}
if (counter == 0)
{ SendSysMessage(LANG_COMMAND_NOQUESTFOUND); }
return true;
}
bool ChatHandler::HandleLookupCreatureCommand(char* args)
{
if (!*args)
{ return false; }
std::string namepart = args;
std::wstring wnamepart;
// converting string that we try to find to lower case
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
wstrToLower(wnamepart);
uint32 counter = 0;
for (uint32 id = 0; id < sCreatureStorage.GetMaxEntry(); ++id)
{
CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo> (id);
if (!cInfo)
{ continue; }
int loc_idx = GetSessionDbLocaleIndex();
char const* name = ""; // "" for avoid repeating check for default locale
sObjectMgr.GetCreatureLocaleStrings(id, loc_idx, &name);
if (!*name || !Utf8FitTo(name, wnamepart))
{
name = cInfo->Name;
if (!Utf8FitTo(name, wnamepart))
{ continue; }
}
if (m_session)
{ PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name); }
else
{ PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name); }
++counter;
}
if (counter == 0)
{ SendSysMessage(LANG_COMMAND_NOCREATUREFOUND); }
return true;
}
bool ChatHandler::HandleLookupObjectCommand(char* args)
{
if (!*args)
{ return false; }
std::string namepart = args;
std::wstring wnamepart;
// converting string that we try to find to lower case
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
wstrToLower(wnamepart);
uint32 counter = 0;
for (SQLStorageBase::SQLSIterator<GameObjectInfo> itr = sGOStorage.getDataBegin<GameObjectInfo>(); itr < sGOStorage.getDataEnd<GameObjectInfo>(); ++itr)
{
int loc_idx = GetSessionDbLocaleIndex();
if (loc_idx >= 0)
{
GameObjectLocale const* gl = sObjectMgr.GetGameObjectLocale(itr->id);
if (gl)
{
if ((int32)gl->Name.size() > loc_idx && !gl->Name[loc_idx].empty())
{
std::string name = gl->Name[loc_idx];
if (Utf8FitTo(name, wnamepart))
{
if (m_session)
{ PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, itr->id, itr->id, name.c_str()); }
else
{ PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, itr->id, name.c_str()); }
++counter;
continue;
}
}
}
}
std::string name = itr->name;
if (name.empty())
{ continue; }
if (Utf8FitTo(name, wnamepart))
{
if (m_session)
{ PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, itr->id, itr->id, name.c_str()); }
else
{ PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, itr->id, name.c_str()); }
++counter;
}
}
if (counter == 0)
{ SendSysMessage(LANG_COMMAND_NOGAMEOBJECTFOUND); }
return true;
}
bool ChatHandler::HandleLookupTaxiNodeCommand(char* args)
{
if (!*args)
{ return false; }
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr(namepart, wnamepart))
{ return false; }
// converting string that we try to find to lower case
wstrToLower(wnamepart);
uint32 counter = 0; // Counter for figure out that we found smth.
// Search in TaxiNodes.dbc
for (uint32 id = 0; id < sTaxiNodesStore.GetNumRows(); ++id)
{
TaxiNodesEntry const* nodeEntry = sTaxiNodesStore.LookupEntry(id);
if (nodeEntry)
{
int loc = GetSessionDbcLocale();
std::string name = nodeEntry->name[loc];
if (name.empty())
{ continue; }
if (!Utf8FitTo(name, wnamepart))
{
loc = 0;
for (; loc < MAX_LOCALE; ++loc)
{
if (loc == GetSessionDbcLocale())
{ continue; }
name = nodeEntry->name[loc];
if (name.empty())
{ continue; }
if (Utf8FitTo(name, wnamepart))
{ break; }
}
}
if (loc < MAX_LOCALE)
{
// send taxinode in "id - [name] (Map:m X:x Y:y Z:z)" format
if (m_session)
PSendSysMessage(LANG_TAXINODE_ENTRY_LIST_CHAT, id, id, name.c_str(), localeNames[loc],
nodeEntry->map_id, nodeEntry->x, nodeEntry->y, nodeEntry->z);
else
PSendSysMessage(LANG_TAXINODE_ENTRY_LIST_CONSOLE, id, name.c_str(), localeNames[loc],
nodeEntry->map_id, nodeEntry->x, nodeEntry->y, nodeEntry->z);
++counter;
}
}
}
if (counter == 0) // if counter == 0 then we found nth
{ SendSysMessage(LANG_COMMAND_NOTAXINODEFOUND); }
return true;
}
/** \brief GM command level 3 - Create a guild.
*
* This command allows a GM (level 3) to create a guild.
*
* The "args" parameter contains the name of the guild leader
* and then the name of the guild.
*
*/
bool ChatHandler::HandleGuildCreateCommand(char* args)
{
// guildmaster name optional
char* guildMasterStr = ExtractOptNotLastArg(&args);
Player* target;
if (!ExtractPlayerTarget(&guildMasterStr, &target))
{ return false; }
char* guildStr = ExtractQuotedArg(&args);
if (!guildStr)
{ return false; }
std::string guildname = guildStr;
if (target->GetGuildId())
{
SendSysMessage(LANG_PLAYER_IN_GUILD);
return true;
}
Guild* guild = new Guild;
if (!guild->Create(target, guildname))
{
delete guild;
SendSysMessage(LANG_GUILD_NOT_CREATED);
SetSentErrorMessage(true);
return false;
}
sGuildMgr.AddGuild(guild);
return true;
}
bool ChatHandler::HandleGuildInviteCommand(char* args)
{
// player name optional
char* nameStr = ExtractOptNotLastArg(&args);
// if not guild name only (in "") then player name
ObjectGuid target_guid;
if (!ExtractPlayerTarget(&nameStr, NULL, &target_guid))
{ return false; }
char* guildStr = ExtractQuotedArg(&args);
if (!guildStr)
{ return false; }
std::string glName = guildStr;
Guild* targetGuild = sGuildMgr.GetGuildByName(glName);
if (!targetGuild)
{ return false; }
// player's guild membership checked in AddMember before add
if (!targetGuild->AddMember(target_guid, targetGuild->GetLowestRank()))
{ return false; }
return true;
}
bool ChatHandler::HandleGuildUninviteCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
if (!ExtractPlayerTarget(&args, &target, &target_guid))
{ return false; }
uint32 glId = target ? target->GetGuildId() : Player::GetGuildIdFromDB(target_guid);
if (!glId)
{ return false; }
Guild* targetGuild = sGuildMgr.GetGuildById(glId);
if (!targetGuild)
{ return false; }
if (targetGuild->DelMember(target_guid))
{
targetGuild->Disband();
delete targetGuild;
}
return true;
}
bool ChatHandler::HandleGuildRankCommand(char* args)
{
char* nameStr = ExtractOptNotLastArg(&args);
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!ExtractPlayerTarget(&nameStr, &target, &target_guid, &target_name))
{ return false; }
uint32 glId = target ? target->GetGuildId() : Player::GetGuildIdFromDB(target_guid);
if (!glId)
{ return false; }
Guild* targetGuild = sGuildMgr.GetGuildById(glId);
if (!targetGuild)
{ return false; }
uint32 newrank;
if (!ExtractUInt32(&args, newrank))
{ return false; }
if (newrank > targetGuild->GetLowestRank())
{ return false; }
MemberSlot* slot = targetGuild->GetMemberSlot(target_guid);
if (!slot)
{ return false; }
slot->ChangeRank(newrank);
return true;
}
bool ChatHandler::HandleGuildDeleteCommand(char* args)
{
if (!*args)
{ return false; }
char* guildStr = ExtractQuotedArg(&args);
if (!guildStr)
{ return false; }
std::string gld = guildStr;
Guild* targetGuild = sGuildMgr.GetGuildByName(gld);
if (!targetGuild)
{ return false; }
targetGuild->Disband();
delete targetGuild;
return true;
}
bool ChatHandler::HandleGetDistanceCommand(char* args)
{
WorldObject* obj = NULL;
if (*args)
{
if (ObjectGuid guid = ExtractGuidFromLink(&args))
{ obj = (WorldObject*)m_session->GetPlayer()->GetObjectByTypeMask(guid, TYPEMASK_CREATURE_OR_GAMEOBJECT); }
if (!obj)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
}
else
{
obj = getSelectedUnit();
if (!obj)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
}
Player* player = m_session->GetPlayer();
// Calculate point-to-point distance
float dx, dy, dz;
dx = player->GetPositionX() - obj->GetPositionX();
dy = player->GetPositionY() - obj->GetPositionY();
dz = player->GetPositionZ() - obj->GetPositionZ();
PSendSysMessage(LANG_DISTANCE, player->GetDistance(obj), player->GetDistance2d(obj), sqrt(dx * dx + dy * dy + dz * dz));
return true;
}
bool ChatHandler::HandleDieCommand(char* /*args*/)
{
Player* player = m_session->GetPlayer();
Unit* target = getSelectedUnit();
if (!target || !player->GetSelectionGuid())
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
if (target->GetTypeId() == TYPEID_PLAYER)
{
if (HasLowerSecurity((Player*)target, ObjectGuid(), false))
{ return false; }
}
if (target->IsAlive())
{
player->DealDamage(target, target->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
return true;
}
bool ChatHandler::HandleDamageCommand(char* args)
{
if (!*args)
{ return false; }
Unit* target = getSelectedUnit();
Player* player = m_session->GetPlayer();
if (!target || !player->GetSelectionGuid())
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
if (!target->IsAlive())
{ return true; }
int32 damage_int;
if (!ExtractInt32(&args, damage_int))
{ return false; }
if (damage_int <= 0)
{ return true; }
uint32 damage = damage_int;
// flat melee damage without resistance/etc reduction
if (!*args)
{
player->DealDamage(target, damage, NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
if (target != player)
{ player->SendAttackStateUpdate(HITINFO_NORMALSWING2, target, SPELL_SCHOOL_MASK_NORMAL, damage, 0, 0, VICTIMSTATE_NORMAL, 0); }
return true;
}
uint32 school;
if (!ExtractUInt32(&args, school))
{ return false; }
if (school >= MAX_SPELL_SCHOOL)
{ return false; }
SpellSchoolMask schoolmask = SpellSchoolMask(1 << school);
if (schoolmask & SPELL_SCHOOL_MASK_NORMAL)
{ damage = player->CalcArmorReducedDamage(target, damage); }
// melee damage by specific school
if (!*args)
{
uint32 absorb = 0;
uint32 resist = 0;
target->CalculateDamageAbsorbAndResist(player, schoolmask, SPELL_DIRECT_DAMAGE, damage, &absorb, &resist);
if (damage <= absorb + resist)
{ return true; }
damage -= absorb + resist;
player->DealDamageMods(target, damage, &absorb);
player->DealDamage(target, damage, NULL, DIRECT_DAMAGE, schoolmask, NULL, false);
player->SendAttackStateUpdate(HITINFO_NORMALSWING2, target, schoolmask, damage, absorb, resist, VICTIMSTATE_NORMAL, 0);
return true;
}
// non-melee damage
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spellid = ExtractSpellIdFromLink(&args);
if (!spellid || !sSpellStore.LookupEntry(spellid))
{ return false; }
player->SpellNonMeleeDamageLog(target, spellid, damage);
return true;
}
bool ChatHandler::HandleModifyArenaCommand(char* args)
{
if (!*args)
return false;
Player* target = getSelectedPlayer();
if (!target)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
int32 amount = (int32)atoi(args);
target->ModifyArenaPoints(amount);
PSendSysMessage(LANG_COMMAND_MODIFY_ARENA, GetNameLink(target).c_str(), target->GetArenaPoints());
return true;
}
bool ChatHandler::HandleReviveCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
if (!ExtractPlayerTarget(&args, &target, &target_guid))
{ return false; }
if (target)
{
target->ResurrectPlayer(0.5f);
target->SpawnCorpseBones();
}
else
// will resurrected at login without corpse
{ sObjectAccessor.ConvertCorpseForPlayer(target_guid); }
return true;
}
bool ChatHandler::HandleAuraCommand(char* args)
{
Unit* target = getSelectedUnit();
if (!target)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spellID = ExtractSpellIdFromLink(&args);
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellID);
if (!spellInfo)
{ return false; }
if (!IsSpellAppliesAura(spellInfo) &&
!IsSpellHaveEffect(spellInfo, SPELL_EFFECT_PERSISTENT_AREA_AURA))
{
PSendSysMessage(LANG_SPELL_NO_HAVE_AURAS, spellID);
SetSentErrorMessage(true);
return false;
}
SpellAuraHolder* holder = CreateSpellAuraHolder(spellInfo, target, m_session->GetPlayer());
for (uint32 i = 0; i < MAX_EFFECT_INDEX; ++i)
{
uint8 eff = spellInfo->Effect[i];
if (eff >= TOTAL_SPELL_EFFECTS)
{ continue; }
if (IsAreaAuraEffect(eff) ||
eff == SPELL_EFFECT_APPLY_AURA ||
eff == SPELL_EFFECT_PERSISTENT_AREA_AURA)
{
Aura* aur = CreateAura(spellInfo, SpellEffectIndex(i), NULL, holder, target);
holder->AddAura(aur, SpellEffectIndex(i));
}
}
target->AddSpellAuraHolder(holder);
return true;
}
bool ChatHandler::HandleUnAuraCommand(char* args)
{
Unit* target = getSelectedUnit();
if (!target)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
std::string argstr = args;
if (argstr == "all")
{
target->RemoveAllAuras();
return true;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spellID = ExtractSpellIdFromLink(&args);
if (!spellID)
{ return false; }
target->RemoveAurasDueToSpell(spellID);
return true;
}
bool ChatHandler::HandleLinkGraveCommand(char* args)
{
uint32 g_id;
if (!ExtractUInt32(&args, g_id))
{ return false; }
char* teamStr = ExtractLiteralArg(&args);
Team g_team;
if (!teamStr)
{ g_team = TEAM_BOTH_ALLOWED; }
else if (strncmp(teamStr, "horde", strlen(teamStr)) == 0)
{ g_team = HORDE; }
else if (strncmp(teamStr, "alliance", strlen(teamStr)) == 0)
{ g_team = ALLIANCE; }
else
{ return false; }
WorldSafeLocsEntry const* graveyard = sWorldSafeLocsStore.LookupEntry(g_id);
if (!graveyard)
{
PSendSysMessage(LANG_COMMAND_GRAVEYARDNOEXIST, g_id);
SetSentErrorMessage(true);
return false;
}
Player* player = m_session->GetPlayer();
uint32 zoneId = player->GetZoneId();
AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(zoneId);
if (!areaEntry || areaEntry->zone != 0)
{
PSendSysMessage(LANG_COMMAND_GRAVEYARDWRONGZONE, g_id, zoneId);
SetSentErrorMessage(true);
return false;
}
if (sObjectMgr.AddGraveYardLink(g_id, zoneId, g_team))
{ PSendSysMessage(LANG_COMMAND_GRAVEYARDLINKED, g_id, zoneId); }
else
{ PSendSysMessage(LANG_COMMAND_GRAVEYARDALRLINKED, g_id, zoneId); }
return true;
}
bool ChatHandler::HandleNearGraveCommand(char* args)
{
Team g_team;
size_t argslen = strlen(args);
if (!*args)
{ g_team = TEAM_BOTH_ALLOWED; }
else if (strncmp(args, "horde", argslen) == 0)
{ g_team = HORDE; }
else if (strncmp(args, "alliance", argslen) == 0)
{ g_team = ALLIANCE; }
else
{ return false; }
Player* player = m_session->GetPlayer();
uint32 zone_id = player->GetZoneId();
WorldSafeLocsEntry const* graveyard = sObjectMgr.GetClosestGraveYard(player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), g_team);
if (graveyard)
{
uint32 g_id = graveyard->ID;
GraveYardData const* data = sObjectMgr.FindGraveYardData(g_id, zone_id);
if (!data)
{
PSendSysMessage(LANG_COMMAND_GRAVEYARDERROR, g_id);
SetSentErrorMessage(true);
return false;
}
std::string team_name;
if (data->team == TEAM_BOTH_ALLOWED)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ANY); }
else if (data->team == HORDE)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_HORDE); }
else if (data->team == ALLIANCE)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ALLIANCE); }
else // Actually, this case can not happen
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_NOTEAM); }
PSendSysMessage(LANG_COMMAND_GRAVEYARDNEAREST, g_id, team_name.c_str(), zone_id);
}
else
{
std::string team_name;
if (g_team == TEAM_BOTH_ALLOWED)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ANY); }
else if (g_team == HORDE)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_HORDE); }
else if (g_team == ALLIANCE)
{ team_name = GetMangosString(LANG_COMMAND_GRAVEYARD_ALLIANCE); }
if (g_team == TEAM_BOTH_ALLOWED)
{ PSendSysMessage(LANG_COMMAND_ZONENOGRAVEYARDS, zone_id); }
else
{ PSendSysMessage(LANG_COMMAND_ZONENOGRAFACTION, zone_id, team_name.c_str()); }
}
return true;
}
//-----------------------Npc Commands-----------------------
bool ChatHandler::HandleNpcAllowMovementCommand(char* /*args*/)
{
if (sWorld.getAllowMovement())
{
sWorld.SetAllowMovement(false);
SendSysMessage(LANG_CREATURE_MOVE_DISABLED);
}
else
{
sWorld.SetAllowMovement(true);
SendSysMessage(LANG_CREATURE_MOVE_ENABLED);
}
return true;
}
bool ChatHandler::HandleNpcChangeEntryCommand(char* args)
{
if (!*args)
{ return false; }
uint32 newEntryNum = atoi(args);
if (!newEntryNum)
{ return false; }
Unit* unit = getSelectedUnit();
if (!unit || unit->GetTypeId() != TYPEID_UNIT)
{
SendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
Creature* creature = (Creature*)unit;
if (creature->UpdateEntry(newEntryNum))
{ SendSysMessage(LANG_DONE); }
else
{ SendSysMessage(LANG_ERROR); }
return true;
}
bool ChatHandler::HandleNpcInfoCommand(char* /*args*/)
{
Creature* target = getSelectedCreature();
if (!target)
{
SendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
uint32 faction = target->getFaction();
uint32 npcflags = target->GetUInt32Value(UNIT_NPC_FLAGS);
uint32 displayid = target->GetDisplayId();
uint32 nativeid = target->GetNativeDisplayId();
uint32 Entry = target->GetEntry();
CreatureInfo const* cInfo = target->GetCreatureInfo();
time_t curRespawnDelay = target->GetRespawnTimeEx() - time(NULL);
if (curRespawnDelay < 0)
{ curRespawnDelay = 0; }
std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay, true);
std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(), true);
// Send information dependend on difficulty mode
CreatureInfo const* baseInfo = ObjectMgr::GetCreatureTemplate(Entry);
uint32 diff = 1;
for (; diff < MAX_DIFFICULTY; ++diff)
if (baseInfo->DifficultyEntry[diff - 1] == target->GetCreatureInfo()->Entry)
break;
if (diff < MAX_DIFFICULTY)
PSendSysMessage(LANG_NPCINFO_CHAR_DIFFICULTY, target->GetGuidStr().c_str(), faction, npcflags,
Entry, target->GetCreatureInfo()->Entry, diff,
displayid, nativeid);
else
PSendSysMessage(LANG_NPCINFO_CHAR, target->GetGuidStr().c_str(), faction, npcflags, Entry, displayid, nativeid);
PSendSysMessage(LANG_NPCINFO_LEVEL, target->getLevel());
PSendSysMessage(LANG_NPCINFO_HEALTH, target->GetCreateHealth(), target->GetMaxHealth(), target->GetHealth());
PSendSysMessage(LANG_NPCINFO_FLAGS, target->GetUInt32Value(UNIT_FIELD_FLAGS), target->GetUInt32Value(UNIT_DYNAMIC_FLAGS), target->getFaction());
PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(), curRespawnDelayStr.c_str());
PSendSysMessage(LANG_NPCINFO_LOOT, cInfo->LootId, cInfo->PickpocketLootId, cInfo->SkinningLootId);
PSendSysMessage(LANG_NPCINFO_DUNGEON_ID, target->GetInstanceId());
PSendSysMessage(LANG_NPCINFO_POSITION, float(target->GetPositionX()), float(target->GetPositionY()), float(target->GetPositionZ()));
if ((npcflags & UNIT_NPC_FLAG_VENDOR))
{
SendSysMessage(LANG_NPCINFO_VENDOR);
}
if ((npcflags & UNIT_NPC_FLAG_TRAINER))
{
SendSysMessage(LANG_NPCINFO_TRAINER);
}
ShowNpcOrGoSpawnInformation<Creature>(target->GetGUIDLow());
return true;
}
// play npc emote
bool ChatHandler::HandleNpcPlayEmoteCommand(char* args)
{
uint32 emote = atoi(args);
Creature* target = getSelectedCreature();
if (!target)
{
SendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
target->HandleEmote(emote);
return true;
}
// TODO: NpcCommands that needs to be fixed :
bool ChatHandler::HandleNpcAddWeaponCommand(char* /*args*/)
{
/*if (!*args)
return false;
ObjectGuid guid = m_session->GetPlayer()->GetSelectionGuid();
if (guid.IsEmpty())
{
SendSysMessage(LANG_NO_SELECTION);
return true;
}
Creature *pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
if(!pCreature)
{
SendSysMessage(LANG_SELECT_CREATURE);
return true;
}
char* pSlotID = strtok((char*)args, " ");
if (!pSlotID)
return false;
char* pItemID = strtok(NULL, " ");
if (!pItemID)
return false;
uint32 ItemID = atoi(pItemID);
uint32 SlotID = atoi(pSlotID);
ItemPrototype* tmpItem = ObjectMgr::GetItemPrototype(ItemID);
bool added = false;
if(tmpItem)
{
switch(SlotID)
{
case 1:
pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, ItemID);
added = true;
break;
case 2:
pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_01, ItemID);
added = true;
break;
case 3:
pCreature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_02, ItemID);
added = true;
break;
default:
PSendSysMessage(LANG_ITEM_SLOT_NOT_EXIST,SlotID);
added = false;
break;
}
if(added)
PSendSysMessage(LANG_ITEM_ADDED_TO_SLOT,ItemID,tmpItem->Name1,SlotID);
}
else
{
PSendSysMessage(LANG_ITEM_NOT_FOUND,ItemID);
return true;
}
*/
return true;
}
//----------------------------------------------------------
bool ChatHandler::HandleExploreCheatCommand(char* args)
{
if (!*args)
{ return false; }
int flag = atoi(args);
Player* chr = getSelectedPlayer();
if (chr == NULL)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
if (flag != 0)
{
PSendSysMessage(LANG_YOU_SET_EXPLORE_ALL, GetNameLink(chr).c_str());
if (needReportToTarget(chr))
{ ChatHandler(chr).PSendSysMessage(LANG_YOURS_EXPLORE_SET_ALL, GetNameLink().c_str()); }
}
else
{
PSendSysMessage(LANG_YOU_SET_EXPLORE_NOTHING, GetNameLink(chr).c_str());
if (needReportToTarget(chr))
{ ChatHandler(chr).PSendSysMessage(LANG_YOURS_EXPLORE_SET_NOTHING, GetNameLink().c_str()); }
}
for (uint8 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
{
if (flag != 0)
{
m_session->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1 + i, 0xFFFFFFFF);
}
else
{
m_session->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1 + i, 0);
}
}
return true;
}
void ChatHandler::HandleCharacterLevel(Player* player, ObjectGuid player_guid, uint32 oldlevel, uint32 newlevel)
{
if (player)
{
player->GiveLevel(newlevel);
player->InitTalentForLevel();
player->SetUInt32Value(PLAYER_XP, 0);
if (needReportToTarget(player))
{
if (oldlevel == newlevel)
{ ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_PROGRESS_RESET, GetNameLink().c_str()); }
else if (oldlevel < newlevel)
{ ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_UP, GetNameLink().c_str(), newlevel); }
else // if(oldlevel > newlevel)
{ ChatHandler(player).PSendSysMessage(LANG_YOURS_LEVEL_DOWN, GetNameLink().c_str(), newlevel); }
}
}
else
{
// update level and XP at level, all other will be updated at loading
CharacterDatabase.PExecute("UPDATE characters SET level = '%u', xp = 0 WHERE guid = '%u'", newlevel, player_guid.GetCounter());
}
}
bool ChatHandler::HandleCharacterLevelCommand(char* args)
{
char* nameStr = ExtractOptNotLastArg(&args);
int32 newlevel;
bool nolevel = false;
// exception opt second arg: .character level $name
if (!ExtractInt32(&args, newlevel))
{
if (!nameStr)
{
nameStr = ExtractArg(&args);
if (!nameStr)
{ return false; }
nolevel = true;
}
else
{ return false; }
}
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!ExtractPlayerTarget(&nameStr, &target, &target_guid, &target_name))
{ return false; }
int32 oldlevel = target ? target->getLevel() : Player::GetLevelFromDB(target_guid);
if (nolevel)
{ newlevel = oldlevel; }
if (newlevel < 1)
{ return false; } // invalid level
if (newlevel > STRONG_MAX_LEVEL) // hardcoded maximum level
{ newlevel = STRONG_MAX_LEVEL; }
HandleCharacterLevel(target, target_guid, oldlevel, newlevel);
if (!m_session || m_session->GetPlayer() != target) // including player==NULL
{
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_YOU_CHANGE_LVL, nameLink.c_str(), newlevel);
}
return true;
}
bool ChatHandler::HandleLevelUpCommand(char* args)
{
int32 addlevel = 1;
char* nameStr = NULL;
if (*args)
{
nameStr = ExtractOptNotLastArg(&args);
// exception opt second arg: .levelup $name
if (!ExtractInt32(&args, addlevel))
{
if (!nameStr)
{ nameStr = ExtractArg(&args); }
else
{ return false; }
}
}
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!ExtractPlayerTarget(&nameStr, &target, &target_guid, &target_name))
{ return false; }
int32 oldlevel = target ? target->getLevel() : Player::GetLevelFromDB(target_guid);
int32 newlevel = oldlevel + addlevel;
if (newlevel < 1)
{ newlevel = 1; }
if (newlevel > STRONG_MAX_LEVEL) // hardcoded maximum level
{ newlevel = STRONG_MAX_LEVEL; }
HandleCharacterLevel(target, target_guid, oldlevel, newlevel);
if (!m_session || m_session->GetPlayer() != target) // including chr==NULL
{
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_YOU_CHANGE_LVL, nameLink.c_str(), newlevel);
}
return true;
}
bool ChatHandler::HandleShowAreaCommand(char* args)
{
if (!*args)
{ return false; }
Player* chr = getSelectedPlayer();
if (chr == NULL)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
int area = GetAreaFlagByAreaID(atoi(args));
int offset = area / 32;
uint32 val = (uint32)(1 << (area % 32));
if (area < 0 || offset >= PLAYER_EXPLORED_ZONES_SIZE)
{
SendSysMessage(LANG_BAD_VALUE);
SetSentErrorMessage(true);
return false;
}
uint32 currFields = chr->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
chr->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, (uint32)(currFields | val));
SendSysMessage(LANG_EXPLORE_AREA);
return true;
}
bool ChatHandler::HandleHideAreaCommand(char* args)
{
if (!*args)
{ return false; }
Player* chr = getSelectedPlayer();
if (chr == NULL)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
int area = GetAreaFlagByAreaID(atoi(args));
int offset = area / 32;
uint32 val = (uint32)(1 << (area % 32));
if (area < 0 || offset >= PLAYER_EXPLORED_ZONES_SIZE)
{
SendSysMessage(LANG_BAD_VALUE);
SetSentErrorMessage(true);
return false;
}
uint32 currFields = chr->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
chr->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, (uint32)(currFields ^ val));
SendSysMessage(LANG_UNEXPLORE_AREA);
return true;
}
bool ChatHandler::HandleAuctionAllianceCommand(char* /*args*/)
{
m_session->GetPlayer()->SetAuctionAccessMode(m_session->GetPlayer()->GetTeam() != ALLIANCE ? -1 : 0);
m_session->SendAuctionHello(m_session->GetPlayer());
return true;
}
bool ChatHandler::HandleAuctionHordeCommand(char* /*args*/)
{
m_session->GetPlayer()->SetAuctionAccessMode(m_session->GetPlayer()->GetTeam() != HORDE ? -1 : 0);
m_session->SendAuctionHello(m_session->GetPlayer());
return true;
}
bool ChatHandler::HandleAuctionGoblinCommand(char* /*args*/)
{
m_session->GetPlayer()->SetAuctionAccessMode(1);
m_session->SendAuctionHello(m_session->GetPlayer());
return true;
}
bool ChatHandler::HandleAuctionCommand(char* /*args*/)
{
m_session->GetPlayer()->SetAuctionAccessMode(0);
m_session->SendAuctionHello(m_session->GetPlayer());
return true;
}
bool ChatHandler::HandleAuctionItemCommand(char* args)
{
// format: (alliance|horde|goblin) item[:count] price [buyout] [short|long|verylong]
char* typeStr = ExtractLiteralArg(&args);
if (!typeStr)
{ return false; }
uint32 houseid;
if (strncmp(typeStr, "alliance", strlen(typeStr)) == 0)
{ houseid = 1; }
else if (strncmp(typeStr, "horde", strlen(typeStr)) == 0)
{ houseid = 6; }
else if (strncmp(typeStr, "goblin", strlen(typeStr)) == 0)
{ houseid = 7; }
else
{ return false; }
// parse item str
char* itemStr = ExtractArg(&args);
if (!itemStr)
{ return false; }
uint32 item_id = 0;
uint32 item_count = 1;
if (sscanf(itemStr, "%u:%u", &item_id, &item_count) != 2)
if (sscanf(itemStr, "%u", &item_id) != 1)
{ return false; }
uint32 price;
if (!ExtractUInt32(&args, price))
{ return false; }
uint32 buyout;
if (!ExtractOptUInt32(&args, buyout, 0))
{ return false; }
uint32 etime = 4 * MIN_AUCTION_TIME;
if (char* timeStr = ExtractLiteralArg(&args))
{
if (strncmp(timeStr, "short", strlen(timeStr)) == 0)
{ etime = 1 * MIN_AUCTION_TIME; }
else if (strncmp(timeStr, "long", strlen(timeStr)) == 0)
{ etime = 2 * MIN_AUCTION_TIME; }
else if (strncmp(timeStr, "verylong", strlen(timeStr)) == 0)
{ etime = 4 * MIN_AUCTION_TIME; }
else
{ return false; }
}
AuctionHouseEntry const* auctionHouseEntry = sAuctionHouseStore.LookupEntry(houseid);
AuctionHouseObject* auctionHouse = sAuctionMgr.GetAuctionsMap(auctionHouseEntry);
if (!item_id)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
ItemPrototype const* item_proto = ObjectMgr::GetItemPrototype(item_id);
if (!item_proto)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
if (item_count < 1 || (item_proto->MaxCount > 0 && item_count > uint32(item_proto->MaxCount)))
{
PSendSysMessage(LANG_COMMAND_INVALID_ITEM_COUNT, item_count, item_id);
SetSentErrorMessage(true);
return false;
}
do
{
uint32 item_stack = item_count > item_proto->GetMaxStackSize() ? item_proto->GetMaxStackSize() : item_count;
item_count -= item_stack;
Item* newItem = Item::CreateItem(item_id, item_stack);
MANGOS_ASSERT(newItem);
auctionHouse->AddAuction(auctionHouseEntry, newItem, etime, price, buyout);
}
while (item_count);
return true;
}
bool ChatHandler::HandleBankCommand(char* /*args*/)
{
m_session->SendShowBank(m_session->GetPlayer()->GetObjectGuid());
return true;
}
bool ChatHandler::HandleMailBoxCommand(char* /*args*/)
{
m_session->SendShowMailBox(m_session->GetPlayer()->GetObjectGuid());
return true;
}
bool ChatHandler::HandleStableCommand(char* /*args*/)
{
m_session->SendStablePet(m_session->GetPlayer()->GetObjectGuid());
return true;
}
bool ChatHandler::HandleChangeWeatherCommand(char* args)
{
// Weather is OFF
if (!sWorld.getConfig(CONFIG_BOOL_WEATHER))
{
SendSysMessage(LANG_WEATHER_DISABLED);
SetSentErrorMessage(true);
return false;
}
uint32 type;
if (!ExtractUInt32(&args, type))
{ return false; }
// see enum WeatherType
if (!Weather::IsValidWeatherType(type))
{ return false; }
float grade;
if (!ExtractFloat(&args, grade))
{ return false; }
// 0 to 1, sending -1 is instant good weather
if (grade < 0.0f || grade > 1.0f)
{ return false; }
Player* player = m_session->GetPlayer();
uint32 zoneId = player->GetZoneId();
if (!sWeatherMgr.GetWeatherChances(zoneId))
{
SendSysMessage(LANG_NO_WEATHER);
SetSentErrorMessage(true);
}
player->GetMap()->SetWeather(zoneId, (WeatherType)type, grade, false);
return true;
}
bool ChatHandler::HandleTeleAddCommand(char* args)
{
if (!*args)
{ return false; }
Player* player = m_session->GetPlayer();
if (!player)
{ return false; }
std::string name = args;
if (sObjectMgr.GetGameTele(name))
{
SendSysMessage(LANG_COMMAND_TP_ALREADYEXIST);
SetSentErrorMessage(true);
return false;
}
GameTele tele;
tele.position_x = player->GetPositionX();
tele.position_y = player->GetPositionY();
tele.position_z = player->GetPositionZ();
tele.orientation = player->GetOrientation();
tele.mapId = player->GetMapId();
tele.name = name;
if (sObjectMgr.AddGameTele(tele))
{
SendSysMessage(LANG_COMMAND_TP_ADDED);
}
else
{
SendSysMessage(LANG_COMMAND_TP_ADDEDERR);
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandleTeleDelCommand(char* args)
{
if (!*args)
{ return false; }
std::string name = args;
if (!sObjectMgr.DeleteGameTele(name))
{
SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
SetSentErrorMessage(true);
return false;
}
SendSysMessage(LANG_COMMAND_TP_DELETED);
return true;
}
bool ChatHandler::HandleListAurasCommand(char* /*args*/)
{
Unit* unit = getSelectedUnit();
if (!unit)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
char const* talentStr = GetMangosString(LANG_TALENT);
char const* passiveStr = GetMangosString(LANG_PASSIVE);
Unit::SpellAuraHolderMap const& uAuras = unit->GetSpellAuraHolderMap();
PSendSysMessage(LANG_COMMAND_TARGET_LISTAURAS, uAuras.size());
for (Unit::SpellAuraHolderMap::const_iterator itr = uAuras.begin(); itr != uAuras.end(); ++itr)
{
bool talent = GetTalentSpellCost(itr->second->GetId()) > 0;
SpellAuraHolder* holder = itr->second;
char const* name = holder->GetSpellProto()->SpellName[GetSessionDbcLocale()];
for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i)
{
Aura* aur = holder->GetAuraByEffectIndex(SpellEffectIndex(i));
if (!aur)
{ continue; }
if (m_session)
{
std::ostringstream ss_name;
ss_name << "|cffffffff|Hspell:" << itr->second->GetId() << "|h[" << name << "]|h|r";
PSendSysMessage(LANG_COMMAND_TARGET_AURADETAIL, holder->GetId(), aur->GetEffIndex(),
aur->GetModifier()->m_auraname, aur->GetAuraDuration(), aur->GetAuraMaxDuration(),
ss_name.str().c_str(),
(holder->IsPassive() ? passiveStr : ""), (talent ? talentStr : ""),
holder->GetCasterGuid().GetString().c_str());
}
else
{
PSendSysMessage(LANG_COMMAND_TARGET_AURADETAIL, holder->GetId(), aur->GetEffIndex(),
aur->GetModifier()->m_auraname, aur->GetAuraDuration(), aur->GetAuraMaxDuration(),
name,
(holder->IsPassive() ? passiveStr : ""), (talent ? talentStr : ""),
holder->GetCasterGuid().GetString().c_str());
}
}
}
for (int i = 0; i < TOTAL_AURAS; ++i)
{
Unit::AuraList const& uAuraList = unit->GetAurasByType(AuraType(i));
if (uAuraList.empty()) { continue; }
PSendSysMessage(LANG_COMMAND_TARGET_LISTAURATYPE, uAuraList.size(), i);
for (Unit::AuraList::const_iterator itr = uAuraList.begin(); itr != uAuraList.end(); ++itr)
{
bool talent = GetTalentSpellCost((*itr)->GetId()) > 0;
char const* name = (*itr)->GetSpellProto()->SpellName[GetSessionDbcLocale()];
if (m_session)
{
std::ostringstream ss_name;
ss_name << "|cffffffff|Hspell:" << (*itr)->GetId() << "|h[" << name << "]|h|r";
PSendSysMessage(LANG_COMMAND_TARGET_AURASIMPLE, (*itr)->GetId(), (*itr)->GetEffIndex(),
ss_name.str().c_str(), ((*itr)->GetHolder()->IsPassive() ? passiveStr : ""), (talent ? talentStr : ""),
(*itr)->GetCasterGuid().GetString().c_str());
}
else
{
PSendSysMessage(LANG_COMMAND_TARGET_AURASIMPLE, (*itr)->GetId(), (*itr)->GetEffIndex(),
name, ((*itr)->GetHolder()->IsPassive() ? passiveStr : ""), (talent ? talentStr : ""),
(*itr)->GetCasterGuid().GetString().c_str());
}
}
}
return true;
}
bool ChatHandler::HandleListTalentsCommand(char* /*args*/)
{
Player* player = getSelectedPlayer();
if (!player)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
SendSysMessage(LANG_LIST_TALENTS_TITLE);
uint32 count = 0;
uint32 cost = 0;
PlayerSpellMap const& uSpells = player->GetSpellMap();
for (PlayerSpellMap::const_iterator itr = uSpells.begin(); itr != uSpells.end(); ++itr)
{
if (itr->second.state == PLAYERSPELL_REMOVED || itr->second.disabled)
{ continue; }
uint32 cost_itr = GetTalentSpellCost(itr->first);
if (cost_itr == 0)
{ continue; }
SpellEntry const* spellEntry = sSpellStore.LookupEntry(itr->first);
if (!spellEntry)
{ continue; }
ShowSpellListHelper(player, spellEntry, GetSessionDbcLocale());
++count;
cost += cost_itr;
}
PSendSysMessage(LANG_LIST_TALENTS_COUNT, count, cost);
return true;
}
bool ChatHandler::HandleResetAchievementsCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
if (!ExtractPlayerTarget(&args, &target, &target_guid))
return false;
if (target)
target->GetAchievementMgr().Reset();
else
AchievementMgr::DeleteFromDB(target_guid);
return true;
}
bool ChatHandler::HandleResetHonorCommand(char* args)
{
Player* target;
if (!ExtractPlayerTarget(&args, &target))
{ return false; }
target->SetHonorPoints(0);
target->SetUInt32Value(PLAYER_FIELD_KILLS, 0);
target->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS, 0);
target->SetUInt32Value(PLAYER_FIELD_TODAY_CONTRIBUTION, 0);
target->SetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION, 0);
target->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL);
return true;
}
static bool HandleResetStatsOrLevelHelper(Player* player)
{
ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(player->getClass());
if (!cEntry)
{
sLog.outError("Class %u not found in DBC (Wrong DBC files?)", player->getClass());
return false;
}
uint8 powertype = cEntry->powerType;
// reset m_form if no aura
if (!player->HasAuraType(SPELL_AURA_MOD_SHAPESHIFT))
{ player->SetShapeshiftForm(FORM_NONE); }
player->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, DEFAULT_WORLD_OBJECT_SIZE);
player->SetFloatValue(UNIT_FIELD_COMBATREACH, 1.5f);
player->setFactionForRace(player->getRace());
player->SetByteValue(UNIT_FIELD_BYTES_0, 3, powertype);
// reset only if player not in some form;
if (player->GetShapeshiftForm() == FORM_NONE)
{ player->InitDisplayIds(); }
player->SetByteValue(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
player->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
//-1 is default value
player->SetInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, -1);
// player->SetUInt32Value(PLAYER_FIELD_BYTES, 0xEEE00000 );
return true;
}
bool ChatHandler::HandleResetLevelCommand(char* args)
{
Player* target;
if (!ExtractPlayerTarget(&args, &target))
{ return false; }
if (!HandleResetStatsOrLevelHelper(target))
{ return false; }
// set starting level
uint32 start_level = target->getClass() != CLASS_DEATH_KNIGHT
? sWorld.getConfig(CONFIG_UINT32_START_PLAYER_LEVEL)
: sWorld.getConfig(CONFIG_UINT32_START_HEROIC_PLAYER_LEVEL);
target->_ApplyAllLevelScaleItemMods(false);
target->SetLevel(start_level);
target->InitRunes();
target->InitStatsForLevel(true);
target->InitTaxiNodesForLevel();
target->InitGlyphsForLevel();
target->InitTalentForLevel();
target->SetUInt32Value(PLAYER_XP, 0);
target->_ApplyAllLevelScaleItemMods(true);
// reset level for pet
if (Pet* pet = target->GetPet())
{ pet->SynchronizeLevelWithOwner(); }
return true;
}
bool ChatHandler::HandleResetStatsCommand(char* args)
{
Player* target;
if (!ExtractPlayerTarget(&args, &target))
{ return false; }
if (!HandleResetStatsOrLevelHelper(target))
{ return false; }
target->InitRunes();
target->InitStatsForLevel(true);
target->InitTaxiNodesForLevel();
target->InitGlyphsForLevel();
target->InitTalentForLevel();
return true;
}
bool ChatHandler::HandleResetSpellsCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!ExtractPlayerTarget(&args, &target, &target_guid, &target_name))
{ return false; }
if (target)
{
target->resetSpells();
ChatHandler(target).SendSysMessage(LANG_RESET_SPELLS);
if (!m_session || m_session->GetPlayer() != target)
{ PSendSysMessage(LANG_RESET_SPELLS_ONLINE, GetNameLink(target).c_str()); }
}
else
{
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE guid = '%u'", uint32(AT_LOGIN_RESET_SPELLS), target_guid.GetCounter());
PSendSysMessage(LANG_RESET_SPELLS_OFFLINE, target_name.c_str());
}
return true;
}
bool ChatHandler::HandleResetSpecsCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!ExtractPlayerTarget(&args, &target, &target_guid, &target_name))
{ return false; }
if (target)
{
target->resetTalents(true, true);
target->SendTalentsInfoData(false);
ChatHandler(target).SendSysMessage(LANG_RESET_TALENTS);
if (!m_session || m_session->GetPlayer() != target)
{ PSendSysMessage(LANG_RESET_TALENTS_ONLINE, GetNameLink(target).c_str()); }
Pet* pet = target->GetPet();
Pet::resetTalentsForAllPetsOf(target, pet);
if (pet)
target->SendTalentsInfoData(true);
return true;
}
else if (target_guid)
{
uint32 at_flags = AT_LOGIN_RESET_TALENTS | AT_LOGIN_RESET_PET_TALENTS;
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE guid = '%u'", at_flags, target_guid.GetCounter());
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_RESET_TALENTS_OFFLINE, nameLink.c_str());
return true;
}
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
bool ChatHandler::HandleResetTalentsCommand(char* args)
{
Player* target;
std::string target_name;
if (!ExtractPlayerTarget(&args, &target, NULL, &target_name))
{
// Try reset talents as Hunter Pet
Creature* creature = getSelectedCreature();
if (!*args && creature && creature->IsPet())
{
Unit* owner = creature->GetOwner();
if (owner && owner->GetTypeId() == TYPEID_PLAYER && ((Pet*)creature)->IsPermanentPetFor((Player*)owner))
{
((Pet*)creature)->resetTalents(true);
((Player*)owner)->SendTalentsInfoData(true);
ChatHandler((Player*)owner).SendSysMessage(LANG_RESET_PET_TALENTS);
if (!m_session || m_session->GetPlayer() != ((Player*)owner))
PSendSysMessage(LANG_RESET_PET_TALENTS_ONLINE, GetNameLink((Player*)owner).c_str());
}
return true;
}
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
if (target)
{
target->resetTalents(true);
target->SendTalentsInfoData(false);
ChatHandler(target).SendSysMessage(LANG_RESET_TALENTS);
if (!m_session || m_session->GetPlayer() != target)
PSendSysMessage(LANG_RESET_TALENTS_ONLINE, GetNameLink(target).c_str());
Pet* pet = target->GetPet();
Pet::resetTalentsForAllPetsOf(target, pet);
if (pet)
target->SendTalentsInfoData(true);
return true;
}
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
bool ChatHandler::HandleResetAllCommand(char* args)
{
if (!*args)
{ return false; }
std::string casename = args;
AtLoginFlags atLogin;
// Command specially created as single command to prevent using short case names
if (casename == "spells")
{
atLogin = AT_LOGIN_RESET_SPELLS;
sWorld.SendWorldText(LANG_RESETALL_SPELLS);
if (!m_session)
{ SendSysMessage(LANG_RESETALL_SPELLS); }
}
else if (casename == "talents")
{
atLogin = AtLoginFlags(AT_LOGIN_RESET_TALENTS | AT_LOGIN_RESET_PET_TALENTS);
sWorld.SendWorldText(LANG_RESETALL_TALENTS);
if (!m_session)
{ SendSysMessage(LANG_RESETALL_TALENTS); }
}
else
{
PSendSysMessage(LANG_RESETALL_UNKNOWN_CASE, args);
SetSentErrorMessage(true);
return false;
}
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '%u' WHERE (at_login & '%u') = '0'", atLogin, atLogin);
HashMapHolder<Player>::MapType const& plist = sObjectAccessor.GetPlayers();
for (HashMapHolder<Player>::MapType::const_iterator itr = plist.begin(); itr != plist.end(); ++itr)
{ itr->second->SetAtLoginFlag(atLogin); }
return true;
}
bool ChatHandler::HandleServerShutDownCancelCommand(char* /*args*/)
{
sWorld.ShutdownCancel();
return true;
}
bool ChatHandler::HandleServerShutDownCommand(char* args)
{
uint32 delay;
if (!ExtractUInt32(&args, delay))
return false;
uint32 exitcode;
if (!ExtractOptUInt32(&args, exitcode, SHUTDOWN_EXIT_CODE))
return false;
// Exit code should be in range of 0-125, 126-255 is used
// in many shells for their own return codes and code > 255
// is not supported in many others
if (exitcode > 125)
return false;
sWorld.ShutdownServ(delay, 0, exitcode);
return true;
}
bool ChatHandler::HandleServerRestartCommand(char* args)
{
uint32 delay;
if (!ExtractUInt32(&args, delay))
{ return false; }
uint32 exitcode;
if (!ExtractOptUInt32(&args, exitcode, RESTART_EXIT_CODE))
{ return false; }
// Exit code should be in range of 0-125, 126-255 is used
// in many shells for their own return codes and code > 255
// is not supported in many others
if (exitcode > 125)
{ return false; }
sWorld.ShutdownServ(delay, SHUTDOWN_MASK_RESTART, exitcode);
return true;
}
bool ChatHandler::HandleServerIdleRestartCommand(char* args)
{
uint32 delay;
if (!ExtractUInt32(&args, delay))
return false;
uint32 exitcode;
if (!ExtractOptUInt32(&args, exitcode, RESTART_EXIT_CODE))
return false;
// Exit code should be in range of 0-125, 126-255 is used
// in many shells for their own return codes and code > 255
// is not supported in many others
if (exitcode > 125)
return false;
sWorld.ShutdownServ(delay, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, exitcode);
return true;
}
bool ChatHandler::HandleServerIdleShutDownCommand(char* args)
{
uint32 delay;
if (!ExtractUInt32(&args, delay))
return false;
uint32 exitcode;
if (!ExtractOptUInt32(&args, exitcode, SHUTDOWN_EXIT_CODE))
return false;
// Exit code should be in range of 0-125, 126-255 is used
// in many shells for their own return codes and code > 255
// is not supported in many others
if (exitcode > 125)
return false;
sWorld.ShutdownServ(delay, SHUTDOWN_MASK_IDLE, exitcode);
return true;
}
bool ChatHandler::HandleQuestAddCommand(char* args)
{
Player* player = getSelectedPlayer();
if (!player)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
// .addquest #entry'
// number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
uint32 entry;
if (!ExtractUint32KeyFromLink(&args, "Hquest", entry))
{ return false; }
Quest const* pQuest = sObjectMgr.GetQuestTemplate(entry);
if (!pQuest)
{
PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
SetSentErrorMessage(true);
return false;
}
// check item starting quest (it can work incorrectly if added without item in inventory)
for (uint32 id = 0; id < sItemStorage.GetMaxEntry(); ++id)
{
ItemPrototype const* pProto = sItemStorage.LookupEntry<ItemPrototype>(id);
if (!pProto)
{ continue; }
if (pProto->StartQuest == entry)
{
PSendSysMessage(LANG_COMMAND_QUEST_STARTFROMITEM, entry, pProto->ItemId);
SetSentErrorMessage(true);
return false;
}
}
// ok, normal (creature/GO starting) quest
if (player->CanAddQuest(pQuest, true))
{
player->AddQuest(pQuest, NULL);
if (player->CanCompleteQuest(entry))
{ player->CompleteQuest(entry); }
}
return true;
}
bool ChatHandler::HandleQuestRemoveCommand(char* args)
{
Player* player = getSelectedPlayer();
if (!player)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
// .removequest #entry'
// number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
uint32 entry;
if (!ExtractUint32KeyFromLink(&args, "Hquest", entry))
{ return false; }
Quest const* pQuest = sObjectMgr.GetQuestTemplate(entry);
if (!pQuest)
{
PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
SetSentErrorMessage(true);
return false;
}
// remove all quest entries for 'entry' from quest log
for (uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot)
{
uint32 quest = player->GetQuestSlotQuestId(slot);
if (quest == entry)
{
player->SetQuestSlot(slot, 0);
// we ignore unequippable quest items in this case, its' still be equipped
player->TakeQuestSourceItem(quest, false);
}
}
// set quest status to not started (will updated in DB at next save)
player->SetQuestStatus(entry, QUEST_STATUS_NONE);
// reset rewarded for restart repeatable quest
player->getQuestStatusMap()[entry].m_rewarded = false;
SendSysMessage(LANG_COMMAND_QUEST_REMOVED);
return true;
}
bool ChatHandler::HandleQuestCompleteCommand(char* args)
{
Player* player = getSelectedPlayer();
if (!player)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true);
return false;
}
// .quest complete #entry
// number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
uint32 entry;
if (!ExtractUint32KeyFromLink(&args, "Hquest", entry))
{ return false; }
Quest const* pQuest = sObjectMgr.GetQuestTemplate(entry);
// If player doesn't have the quest
if (!pQuest || player->GetQuestStatus(entry) == QUEST_STATUS_NONE)
{
PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
SetSentErrorMessage(true);
return false;
}
// Add quest items for quests that require items
for (uint8 x = 0; x < QUEST_ITEM_OBJECTIVES_COUNT; ++x)
{
uint32 id = pQuest->ReqItemId[x];
uint32 count = pQuest->ReqItemCount[x];
if (!id || !count)
{ continue; }
uint32 curItemCount = player->GetItemCount(id, true);
ItemPosCountVec dest;
uint8 msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, id, count - curItemCount);
if (msg == EQUIP_ERR_OK)
{
Item* item = player->StoreNewItem(dest, id, true);
player->SendNewItem(item, count - curItemCount, true, false);
}
}
// All creature/GO slain/casted (not required, but otherwise it will display "Creature slain 0/10")
for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
{
int32 creature = pQuest->ReqCreatureOrGOId[i];
uint32 creaturecount = pQuest->ReqCreatureOrGOCount[i];
if (uint32 spell_id = pQuest->ReqSpell[i])
{
for (uint16 z = 0; z < creaturecount; ++z)
{ player->CastedCreatureOrGO(creature, ObjectGuid(), spell_id); }
}
else if (creature > 0)
{
if (CreatureInfo const* cInfo = ObjectMgr::GetCreatureTemplate(creature))
for (uint16 z = 0; z < creaturecount; ++z)
{ player->KilledMonster(cInfo, ObjectGuid()); }
}
else if (creature < 0)
{
for (uint16 z = 0; z < creaturecount; ++z)
{ player->CastedCreatureOrGO(-creature, ObjectGuid(), 0); }
}
}
// If the quest requires reputation to complete
if (uint32 repFaction = pQuest->GetRepObjectiveFaction())
{
uint32 repValue = pQuest->GetRepObjectiveValue();
uint32 curRep = player->GetReputationMgr().GetReputation(repFaction);
if (curRep < repValue)
if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(repFaction))
{ player->GetReputationMgr().SetReputation(factionEntry, repValue); }
}
// If the quest requires money
int32 ReqOrRewMoney = pQuest->GetRewOrReqMoney();
if (ReqOrRewMoney < 0)
{ player->ModifyMoney(-ReqOrRewMoney); }
player->CompleteQuest(entry);
return true;
}
bool ChatHandler::HandleBanAccountCommand(char* args)
{
return HandleBanHelper(BAN_ACCOUNT, args);
}
bool ChatHandler::HandleBanCharacterCommand(char* args)
{
return HandleBanHelper(BAN_CHARACTER, args);
}
bool ChatHandler::HandleBanIPCommand(char* args)
{
return HandleBanHelper(BAN_IP, args);
}
bool ChatHandler::HandleBanHelper(BanMode mode, char* args)
{
if (!*args)
{ return false; }
char* cnameOrIP = ExtractArg(&args);
if (!cnameOrIP)
{ return false; }
std::string nameOrIP = cnameOrIP;
char* duration = ExtractArg(&args); // time string
if (!duration)
{ return false; }
uint32 duration_secs = TimeStringToSecs(duration);
char* reason = ExtractArg(&args);
if (!reason)
{ return false; }
switch (mode)
{
case BAN_ACCOUNT:
if (!AccountMgr::normalizeString(nameOrIP))
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, nameOrIP.c_str());
SetSentErrorMessage(true);
return false;
}
break;
case BAN_CHARACTER:
if (!normalizePlayerName(nameOrIP))
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
break;
case BAN_IP:
if (!IsIPAddress(nameOrIP.c_str()))
{ return false; }
break;
}
switch (sWorld.BanAccount(mode, nameOrIP, duration_secs, reason, m_session ? m_session->GetPlayerName() : ""))
{
case BAN_SUCCESS:
if (duration_secs > 0)
{ PSendSysMessage(LANG_BAN_YOUBANNED, nameOrIP.c_str(), secsToTimeString(duration_secs, true).c_str(), reason); }
else
{ PSendSysMessage(LANG_BAN_YOUPERMBANNED, nameOrIP.c_str(), reason); }
break;
case BAN_SYNTAX_ERROR:
return false;
case BAN_NOTFOUND:
switch (mode)
{
default:
PSendSysMessage(LANG_BAN_NOTFOUND, "account", nameOrIP.c_str());
break;
case BAN_CHARACTER:
PSendSysMessage(LANG_BAN_NOTFOUND, "character", nameOrIP.c_str());
break;
case BAN_IP:
PSendSysMessage(LANG_BAN_NOTFOUND, "ip", nameOrIP.c_str());
break;
}
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandleUnBanAccountCommand(char* args)
{
return HandleUnBanHelper(BAN_ACCOUNT, args);
}
bool ChatHandler::HandleUnBanCharacterCommand(char* args)
{
return HandleUnBanHelper(BAN_CHARACTER, args);
}
bool ChatHandler::HandleUnBanIPCommand(char* args)
{
return HandleUnBanHelper(BAN_IP, args);
}
bool ChatHandler::HandleUnBanHelper(BanMode mode, char* args)
{
if (!*args)
{ return false; }
char* cnameOrIP = ExtractArg(&args);
if (!cnameOrIP)
{ return false; }
std::string nameOrIP = cnameOrIP;
switch (mode)
{
case BAN_ACCOUNT:
if (!AccountMgr::normalizeString(nameOrIP))
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, nameOrIP.c_str());
SetSentErrorMessage(true);
return false;
}
break;
case BAN_CHARACTER:
if (!normalizePlayerName(nameOrIP))
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
break;
case BAN_IP:
if (!IsIPAddress(nameOrIP.c_str()))
{ return false; }
break;
}
if (sWorld.RemoveBanAccount(mode, nameOrIP))
{ PSendSysMessage(LANG_UNBAN_UNBANNED, nameOrIP.c_str()); }
else
{ PSendSysMessage(LANG_UNBAN_ERROR, nameOrIP.c_str()); }
return true;
}
bool ChatHandler::HandleBanInfoAccountCommand(char* args)
{
if (!*args)
{ return false; }
std::string account_name;
uint32 accountid = ExtractAccountId(&args, &account_name);
if (!accountid)
{ return false; }
return HandleBanInfoHelper(accountid, account_name.c_str());
}
bool ChatHandler::HandleBanInfoCharacterCommand(char* args)
{
Player* target;
ObjectGuid target_guid;
if (!ExtractPlayerTarget(&args, &target, &target_guid))
{ return false; }
uint32 accountid = target ? target->GetSession()->GetAccountId() : sObjectMgr.GetPlayerAccountIdByGUID(target_guid);
std::string accountname;
if (!sAccountMgr.GetName(accountid, accountname))
{
PSendSysMessage(LANG_BANINFO_NOCHARACTER);
return true;
}
return HandleBanInfoHelper(accountid, accountname.c_str());
}
bool ChatHandler::HandleBanInfoHelper(uint32 accountid, char const* accountname)
{
QueryResult* result = LoginDatabase.PQuery("SELECT FROM_UNIXTIME(bandate), unbandate-bandate, active, unbandate,banreason,bannedby FROM account_banned WHERE id = '%u' ORDER BY bandate ASC", accountid);
if (!result)
{
PSendSysMessage(LANG_BANINFO_NOACCOUNTBAN, accountname);
return true;
}
PSendSysMessage(LANG_BANINFO_BANHISTORY, accountname);
do
{
Field* fields = result->Fetch();
time_t unbandate = time_t(fields[3].GetUInt64());
bool active = false;
if (fields[2].GetBool() && (fields[1].GetUInt64() == (uint64)0 || unbandate >= time(NULL)))
{ active = true; }
bool permanent = (fields[1].GetUInt64() == (uint64)0);
std::string bantime = permanent ? GetMangosString(LANG_BANINFO_INFINITE) : secsToTimeString(fields[1].GetUInt64(), true);
PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
fields[0].GetString(), bantime.c_str(), active ? GetMangosString(LANG_BANINFO_YES) : GetMangosString(LANG_BANINFO_NO), fields[4].GetString(), fields[5].GetString());
}
while (result->NextRow());
delete result;
return true;
}
bool ChatHandler::HandleBanInfoIPCommand(char* args)
{
if (!*args)
{ return false; }
char* cIP = ExtractQuotedOrLiteralArg(&args);
if (!cIP)
{ return false; }
if (!IsIPAddress(cIP))
{ return false; }
std::string IP = cIP;
LoginDatabase.escape_string(IP);
QueryResult* result = LoginDatabase.PQuery("SELECT ip, FROM_UNIXTIME(bandate), FROM_UNIXTIME(unbandate), unbandate-UNIX_TIMESTAMP(), banreason,bannedby,unbandate-bandate FROM ip_banned WHERE ip = '%s'", IP.c_str());
if (!result)
{
PSendSysMessage(LANG_BANINFO_NOIP);
return true;
}
Field* fields = result->Fetch();
bool permanent = !fields[6].GetUInt64();
PSendSysMessage(LANG_BANINFO_IPENTRY,
fields[0].GetString(), fields[1].GetString(), permanent ? GetMangosString(LANG_BANINFO_NEVER) : fields[2].GetString(),
permanent ? GetMangosString(LANG_BANINFO_INFINITE) : secsToTimeString(fields[3].GetUInt64(), true).c_str(), fields[4].GetString(), fields[5].GetString());
delete result;
return true;
}
bool ChatHandler::HandleBanListCharacterCommand(char* args)
{
LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
char* cFilter = ExtractLiteralArg(&args);
if (!cFilter)
{ return false; }
std::string filter = cFilter;
LoginDatabase.escape_string(filter);
QueryResult* result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name " _LIKE_ " " _CONCAT3_("'%%'", "'%s'", "'%%'"), filter.c_str());
if (!result)
{
PSendSysMessage(LANG_BANLIST_NOCHARACTER);
return true;
}
return HandleBanListHelper(result);
}
bool ChatHandler::HandleBanListAccountCommand(char* args)
{
LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
char* cFilter = ExtractLiteralArg(&args);
std::string filter = cFilter ? cFilter : "";
LoginDatabase.escape_string(filter);
QueryResult* result;
if (filter.empty())
{
result = LoginDatabase.Query("SELECT account.id, username FROM account, account_banned"
" WHERE account.id = account_banned.id AND active = 1 GROUP BY account.id");
}
else
{
result = LoginDatabase.PQuery("SELECT account.id, username FROM account, account_banned"
" WHERE account.id = account_banned.id AND active = 1 AND username " _LIKE_ " " _CONCAT3_("'%%'", "'%s'", "'%%'")" GROUP BY account.id",
filter.c_str());
}
if (!result)
{
PSendSysMessage(LANG_BANLIST_NOACCOUNT);
return true;
}
return HandleBanListHelper(result);
}
bool ChatHandler::HandleBanListHelper(QueryResult* result)
{
PSendSysMessage(LANG_BANLIST_MATCHINGACCOUNT);
// Chat short output
if (m_session)
{
do
{
Field* fields = result->Fetch();
uint32 accountid = fields[0].GetUInt32();
QueryResult* banresult = LoginDatabase.PQuery("SELECT account.username FROM account,account_banned WHERE account_banned.id='%u' AND account_banned.id=account.id", accountid);
if (banresult)
{
Field* fields2 = banresult->Fetch();
PSendSysMessage("%s", fields2[0].GetString());
delete banresult;
}
}
while (result->NextRow());
}
// Console wide output
else
{
SendSysMessage(LANG_BANLIST_ACCOUNTS);
SendSysMessage("===============================================================================");
SendSysMessage(LANG_BANLIST_ACCOUNTS_HEADER);
do
{
SendSysMessage("-------------------------------------------------------------------------------");
Field* fields = result->Fetch();
uint32 account_id = fields[0].GetUInt32();
std::string account_name;
// "account" case, name can be get in same query
if (result->GetFieldCount() > 1)
{ account_name = fields[1].GetCppString(); }
// "character" case, name need extract from another DB
else
{ sAccountMgr.GetName(account_id, account_name); }
// No SQL injection. id is uint32.
QueryResult* banInfo = LoginDatabase.PQuery("SELECT bandate,unbandate,bannedby,banreason FROM account_banned WHERE id = %u ORDER BY unbandate", account_id);
if (banInfo)
{
Field* fields2 = banInfo->Fetch();
do
{
time_t t_ban = fields2[0].GetUInt64();
tm* aTm_ban = localtime(&t_ban);
if (fields2[0].GetUInt64() == fields2[1].GetUInt64())
{
PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d| permanent |%-15.15s|%-15.15s|",
account_name.c_str(), aTm_ban->tm_year % 100, aTm_ban->tm_mon + 1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
fields2[2].GetString(), fields2[3].GetString());
}
else
{
time_t t_unban = fields2[1].GetUInt64();
tm* aTm_unban = localtime(&t_unban);
PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
account_name.c_str(), aTm_ban->tm_year % 100, aTm_ban->tm_mon + 1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
aTm_unban->tm_year % 100, aTm_unban->tm_mon + 1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
fields2[2].GetString(), fields2[3].GetString());
}
}
while (banInfo->NextRow());
delete banInfo;
}
}
while (result->NextRow());
SendSysMessage("===============================================================================");
}
delete result;
return true;
}
bool ChatHandler::HandleBanListIPCommand(char* args)
{
LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
char* cFilter = ExtractLiteralArg(&args);
std::string filter = cFilter ? cFilter : "";
LoginDatabase.escape_string(filter);
QueryResult* result;
if (filter.empty())
{
result = LoginDatabase.Query("SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
" WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP())"
" ORDER BY unbandate");
}
else
{
result = LoginDatabase.PQuery("SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
" WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP()) AND ip " _LIKE_ " " _CONCAT3_("'%%'", "'%s'", "'%%'")
" ORDER BY unbandate", filter.c_str());
}
if (!result)
{
PSendSysMessage(LANG_BANLIST_NOIP);
return true;
}
PSendSysMessage(LANG_BANLIST_MATCHINGIP);
// Chat short output
if (m_session)
{
do
{
Field* fields = result->Fetch();
PSendSysMessage("%s", fields[0].GetString());
}
while (result->NextRow());
}
// Console wide output
else
{
SendSysMessage(LANG_BANLIST_IPS);
SendSysMessage("===============================================================================");
SendSysMessage(LANG_BANLIST_IPS_HEADER);
do
{
SendSysMessage("-------------------------------------------------------------------------------");
Field* fields = result->Fetch();
time_t t_ban = fields[1].GetUInt64();
tm* aTm_ban = localtime(&t_ban);
if (fields[1].GetUInt64() == fields[2].GetUInt64())
{
PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d| permanent |%-15.15s|%-15.15s|",
fields[0].GetString(), aTm_ban->tm_year % 100, aTm_ban->tm_mon + 1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
fields[3].GetString(), fields[4].GetString());
}
else
{
time_t t_unban = fields[2].GetUInt64();
tm* aTm_unban = localtime(&t_unban);
PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
fields[0].GetString(), aTm_ban->tm_year % 100, aTm_ban->tm_mon + 1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
aTm_unban->tm_year % 100, aTm_unban->tm_mon + 1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
fields[3].GetString(), fields[4].GetString());
}
}
while (result->NextRow());
SendSysMessage("===============================================================================");
}
delete result;
return true;
}
bool ChatHandler::HandleRespawnCommand(char* /*args*/)
{
Player* pl = m_session->GetPlayer();
// accept only explicitly selected target (not implicitly self targeting case)
Unit* target = getSelectedUnit();
if (pl->GetSelectionGuid() && target)
{
if (target->GetTypeId() != TYPEID_UNIT)
{
SendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
if (target->IsDead())
{ ((Creature*)target)->Respawn(); }
return true;
}
MaNGOS::RespawnDo u_do;
MaNGOS::WorldObjectWorker<MaNGOS::RespawnDo> worker(pl, u_do);
Cell::VisitGridObjects(pl, worker, pl->GetMap()->GetVisibilityDistance());
return true;
}
bool ChatHandler::HandleGMFlyCommand(char* args)
{
bool value;
if (!ExtractOnOff(&args, value))
{
SendSysMessage(LANG_USE_BOL);
SetSentErrorMessage(true);
return false;
}
Player* target = getSelectedPlayer();
if (!target)
{ target = m_session->GetPlayer(); }
target->SetCanFly(value);
PSendSysMessage(LANG_COMMAND_FLYMODE_STATUS, GetNameLink(target).c_str(), args);
return true;
}
bool ChatHandler::HandlePDumpLoadCommand(char* args)
{
char* file = ExtractQuotedOrLiteralArg(&args);
if (!file)
{ return false; }
std::string account_name;
uint32 account_id = ExtractAccountId(&args, &account_name);
if (!account_id)
{ return false; }
char* name_str = ExtractLiteralArg(&args);
uint32 lowguid = 0;
std::string name;
if (name_str)
{
name = name_str;
// normalize the name if specified and check if it exists
if (!normalizePlayerName(name))
{
PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
SetSentErrorMessage(true);
return false;
}
if (ObjectMgr::CheckPlayerName(name, true) != CHAR_NAME_SUCCESS)
{
PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
SetSentErrorMessage(true);
return false;
}
if (*args)
{
if (!ExtractUInt32(&args, lowguid))
{ return false; }
if (!lowguid)
{
PSendSysMessage(LANG_INVALID_CHARACTER_GUID);
SetSentErrorMessage(true);
return false;
}
ObjectGuid guid = ObjectGuid(HIGHGUID_PLAYER, lowguid);
if (sObjectMgr.GetPlayerAccountIdByGUID(guid))
{
PSendSysMessage(LANG_CHARACTER_GUID_IN_USE, lowguid);
SetSentErrorMessage(true);
return false;
}
}
}
switch (PlayerDumpReader().LoadDump(file, account_id, name, lowguid))
{
case DUMP_SUCCESS:
PSendSysMessage(LANG_COMMAND_IMPORT_SUCCESS);
break;
case DUMP_FILE_OPEN_ERROR:
PSendSysMessage(LANG_FILE_OPEN_FAIL, file);
SetSentErrorMessage(true);
return false;
case DUMP_FILE_BROKEN:
PSendSysMessage(LANG_DUMP_BROKEN, file);
SetSentErrorMessage(true);
return false;
case DUMP_TOO_MANY_CHARS:
PSendSysMessage(LANG_ACCOUNT_CHARACTER_LIST_FULL, account_name.c_str(), account_id);
SetSentErrorMessage(true);
return false;
default:
PSendSysMessage(LANG_COMMAND_IMPORT_FAILED);
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandlePDumpWriteCommand(char* args)
{
if (!*args)
{ return false; }
char* file = ExtractQuotedOrLiteralArg(&args);
if (!file)
{ return false; }
char* p2 = ExtractLiteralArg(&args);
uint32 lowguid;
ObjectGuid guid;
// character name can't start from number
if (!ExtractUInt32(&p2, lowguid))
{
std::string name = ExtractPlayerNameFromLink(&p2);
if (name.empty())
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
guid = sObjectMgr.GetPlayerGuidByName(name);
if (!guid)
{
PSendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
lowguid = guid.GetCounter();
}
else
{ guid = ObjectGuid(HIGHGUID_PLAYER, lowguid); }
if (!sObjectMgr.GetPlayerAccountIdByGUID(guid))
{
PSendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
switch (PlayerDumpWriter().WriteDump(file, lowguid))
{
case DUMP_SUCCESS:
PSendSysMessage(LANG_COMMAND_EXPORT_SUCCESS);
break;
case DUMP_FILE_OPEN_ERROR:
PSendSysMessage(LANG_FILE_OPEN_FAIL, file);
SetSentErrorMessage(true);
return false;
default:
PSendSysMessage(LANG_COMMAND_EXPORT_FAILED);
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandleMovegensCommand(char* /*args*/)
{
Unit* unit = getSelectedUnit();
if (!unit)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
PSendSysMessage(LANG_MOVEGENS_LIST, (unit->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), unit->GetGUIDLow());
MotionMaster* mm = unit->GetMotionMaster();
float x, y, z;
mm->GetDestination(x, y, z);
for (MotionMaster::const_iterator itr = mm->begin(); itr != mm->end(); ++itr)
{
switch ((*itr)->GetMovementGeneratorType())
{
case IDLE_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_IDLE); break;
case RANDOM_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_RANDOM); break;
case WAYPOINT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_WAYPOINT); break;
case CONFUSED_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_CONFUSED); break;
case CHASE_MOTION_TYPE:
{
Unit* target = NULL;
if (unit->GetTypeId() == TYPEID_PLAYER)
{ target = static_cast<ChaseMovementGenerator<Player> const*>(*itr)->GetTarget(); }
else
{ target = static_cast<ChaseMovementGenerator<Creature> const*>(*itr)->GetTarget(); }
if (!target)
{ SendSysMessage(LANG_MOVEGENS_CHASE_NULL); }
else if (target->GetTypeId() == TYPEID_PLAYER)
{ PSendSysMessage(LANG_MOVEGENS_CHASE_PLAYER, target->GetName(), target->GetGUIDLow()); }
else
{ PSendSysMessage(LANG_MOVEGENS_CHASE_CREATURE, target->GetName(), target->GetGUIDLow()); }
break;
}
case FOLLOW_MOTION_TYPE:
{
Unit* target = NULL;
if (unit->GetTypeId() == TYPEID_PLAYER)
{ target = static_cast<FollowMovementGenerator<Player> const*>(*itr)->GetTarget(); }
else
{ target = static_cast<FollowMovementGenerator<Creature> const*>(*itr)->GetTarget(); }
if (!target)
{ SendSysMessage(LANG_MOVEGENS_FOLLOW_NULL); }
else if (target->GetTypeId() == TYPEID_PLAYER)
{ PSendSysMessage(LANG_MOVEGENS_FOLLOW_PLAYER, target->GetName(), target->GetGUIDLow()); }
else
{ PSendSysMessage(LANG_MOVEGENS_FOLLOW_CREATURE, target->GetName(), target->GetGUIDLow()); }
break;
}
case HOME_MOTION_TYPE:
if (unit->GetTypeId() == TYPEID_UNIT)
{
PSendSysMessage(LANG_MOVEGENS_HOME_CREATURE, x, y, z);
}
else
{ SendSysMessage(LANG_MOVEGENS_HOME_PLAYER); }
break;
case FLIGHT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_FLIGHT); break;
case POINT_MOTION_TYPE:
{
PSendSysMessage(LANG_MOVEGENS_POINT, x, y, z);
break;
}
case FLEEING_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_FEAR); break;
case DISTRACT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_DISTRACT); break;
case EFFECT_MOTION_TYPE: SendSysMessage(LANG_MOVEGENS_EFFECT); break;
default:
PSendSysMessage(LANG_MOVEGENS_UNKNOWN, (*itr)->GetMovementGeneratorType());
break;
}
}
return true;
}
bool ChatHandler::HandleServerPLimitCommand(char* args)
{
if (*args)
{
char* param = ExtractLiteralArg(&args);
if (!param)
{ return false; }
int l = strlen(param);
int val;
if (strncmp(param, "player", l) == 0)
{ sWorld.SetPlayerLimit(-SEC_PLAYER); }
else if (strncmp(param, "moderator", l) == 0)
{ sWorld.SetPlayerLimit(-SEC_MODERATOR); }
else if (strncmp(param, "gamemaster", l) == 0)
{ sWorld.SetPlayerLimit(-SEC_GAMEMASTER); }
else if (strncmp(param, "administrator", l) == 0)
{ sWorld.SetPlayerLimit(-SEC_ADMINISTRATOR); }
else if (strncmp(param, "reset", l) == 0)
{ sWorld.SetPlayerLimit(sConfig.GetIntDefault("PlayerLimit", DEFAULT_PLAYER_LIMIT)); }
else if (ExtractInt32(¶m, val))
{
if (val < -SEC_ADMINISTRATOR)
{ val = -SEC_ADMINISTRATOR; }
sWorld.SetPlayerLimit(val);
}
else
{ return false; }
// kick all low security level players
if (sWorld.GetPlayerAmountLimit() > SEC_PLAYER)
{ sWorld.KickAllLess(sWorld.GetPlayerSecurityLimit()); }
}
uint32 pLimit = sWorld.GetPlayerAmountLimit();
AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit();
char const* secName = "";
switch (allowedAccountType)
{
case SEC_PLAYER: secName = "Player"; break;
case SEC_MODERATOR: secName = "Moderator"; break;
case SEC_GAMEMASTER: secName = "Gamemaster"; break;
case SEC_ADMINISTRATOR: secName = "Administrator"; break;
default: secName = "<unknown>"; break;
}
PSendSysMessage("Player limits: amount %u, min. security level %s.", pLimit, secName);
return true;
}
bool ChatHandler::HandleCastCommand(char* args)
{
if (!*args)
{ return false; }
Unit* target = getSelectedUnit();
if (!target)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell)
{ return false; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo)
{ return false; }
if (!SpellMgr::IsSpellValid(spellInfo, m_session->GetPlayer()))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
SetSentErrorMessage(true);
return false;
}
bool triggered = ExtractLiteralArg(&args, "triggered") != NULL;
if (!triggered && *args) // can be fail also at syntax error
{ return false; }
m_session->GetPlayer()->CastSpell(target, spell, triggered);
return true;
}
bool ChatHandler::HandleCastBackCommand(char* args)
{
Creature* caster = getSelectedCreature();
if (!caster)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell || !sSpellStore.LookupEntry(spell))
{ return false; }
bool triggered = ExtractLiteralArg(&args, "triggered") != NULL;
if (!triggered && *args) // can be fail also at syntax error
{ return false; }
caster->SetFacingToObject(m_session->GetPlayer());
caster->CastSpell(m_session->GetPlayer(), spell, triggered);
return true;
}
bool ChatHandler::HandleCastDistCommand(char* args)
{
if (!*args)
{ return false; }
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell)
{ return false; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo)
{ return false; }
if (!SpellMgr::IsSpellValid(spellInfo, m_session->GetPlayer()))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
SetSentErrorMessage(true);
return false;
}
float dist;
if (!ExtractFloat(&args, dist))
{ return false; }
bool triggered = ExtractLiteralArg(&args, "triggered") != NULL;
if (!triggered && *args) // can be fail also at syntax error
{ return false; }
float x, y, z;
m_session->GetPlayer()->GetClosePoint(x, y, z, dist);
m_session->GetPlayer()->CastSpell(x, y, z, spell, triggered);
return true;
}
bool ChatHandler::HandleCastTargetCommand(char* args)
{
Creature* caster = getSelectedCreature();
if (!caster)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
if (!caster->getVictim())
{
SendSysMessage(LANG_SELECTED_TARGET_NOT_HAVE_VICTIM);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell || !sSpellStore.LookupEntry(spell))
{ return false; }
bool triggered = ExtractLiteralArg(&args, "triggered") != NULL;
if (!triggered && *args) // can be fail also at syntax error
{ return false; }
caster->SetFacingToObject(m_session->GetPlayer());
caster->CastSpell(caster->getVictim(), spell, triggered);
return true;
}
/*
ComeToMe command REQUIRED for 3rd party scripting library to have access to PointMovementGenerator
Without this function 3rd party scripting library will get linking errors (unresolved external)
when attempting to use the PointMovementGenerator
*/
bool ChatHandler::HandleComeToMeCommand(char* /*args*/)
{
Creature* caster = getSelectedCreature();
if (!caster)
{
SendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
Player* pl = m_session->GetPlayer();
caster->GetMotionMaster()->MovePoint(0, pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ());
return true;
}
bool ChatHandler::HandleCastSelfCommand(char* args)
{
if (!*args)
{ return false; }
Unit* target = getSelectedUnit();
if (!target)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
// number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
uint32 spell = ExtractSpellIdFromLink(&args);
if (!spell)
{ return false; }
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell);
if (!spellInfo)
{ return false; }
if (!SpellMgr::IsSpellValid(spellInfo, m_session->GetPlayer()))
{
PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
SetSentErrorMessage(true);
return false;
}
bool triggered = ExtractLiteralArg(&args, "triggered") != NULL;
if (!triggered && *args) // can be fail also at syntax error
{ return false; }
target->CastSpell(target, spell, triggered);
return true;
}
bool ChatHandler::HandleInstanceListBindsCommand(char* /*args*/)
{
Player* player = getSelectedPlayer();
if (!player) { player = m_session->GetPlayer(); }
uint32 counter = 0;
for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
{
Player::BoundInstancesMap& binds = player->GetBoundInstances(Difficulty(i));
for (Player::BoundInstancesMap::const_iterator itr = binds.begin(); itr != binds.end(); ++itr)
{
DungeonPersistentState* state = itr->second.state;
std::string timeleft = secsToTimeString(state->GetResetTime() - time(NULL), true);
if (const MapEntry* entry = sMapStore.LookupEntry(itr->first))
{
PSendSysMessage("map: %d (%s) inst: %d perm: %s diff: %d canReset: %s TTR: %s",
itr->first, entry->name[GetSessionDbcLocale()], state->GetInstanceId(), itr->second.perm ? "yes" : "no",
state->GetDifficulty(), state->CanReset() ? "yes" : "no", timeleft.c_str());
}
else
PSendSysMessage("bound for a nonexistent map %u", itr->first);
++counter;
}
}
PSendSysMessage("player binds: %d", counter);
counter = 0;
if (Group* group = player->GetGroup())
{
for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
{
Group::BoundInstancesMap& binds = group->GetBoundInstances(Difficulty(i));
for (Group::BoundInstancesMap::const_iterator itr = binds.begin(); itr != binds.end(); ++itr)
{
DungeonPersistentState* state = itr->second.state;
std::string timeleft = secsToTimeString(state->GetResetTime() - time(NULL), true);
if (const MapEntry* entry = sMapStore.LookupEntry(itr->first))
{
PSendSysMessage("map: %d (%s) inst: %d perm: %s diff: %d canReset: %s TTR: %s",
itr->first, entry->name[GetSessionDbcLocale()], state->GetInstanceId(), itr->second.perm ? "yes" : "no",
state->GetDifficulty(), state->CanReset() ? "yes" : "no", timeleft.c_str());
}
else
PSendSysMessage("bound for a nonexistent map %u", itr->first);
++counter;
}
}
}
PSendSysMessage("group binds: %d", counter);
return true;
}
bool ChatHandler::HandleInstanceUnbindCommand(char* args)
{
if (!*args)
{ return false; }
Player* player = getSelectedPlayer();
if (!player)
{ player = m_session->GetPlayer(); }
uint32 counter = 0;
uint32 mapid = 0;
bool got_map = false;
if (strncmp(args, "all", strlen(args)) != 0)
{
if (!isNumeric(args[0]))
{ return false; }
got_map = true;
mapid = atoi(args);
}
for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
{
Player::BoundInstancesMap& binds = player->GetBoundInstances(Difficulty(i));
for (Player::BoundInstancesMap::iterator itr = binds.begin(); itr != binds.end();)
{
if (got_map && mapid != itr->first)
{
++itr;
continue;
}
if (itr->first != player->GetMapId())
{
DungeonPersistentState* save = itr->second.state;
std::string timeleft = secsToTimeString(save->GetResetTime() - time(NULL), true);
if (const MapEntry* entry = sMapStore.LookupEntry(itr->first))
{
PSendSysMessage("unbinding map: %d (%s) inst: %d perm: %s diff: %d canReset: %s TTR: %s",
itr->first, entry->name[GetSessionDbcLocale()], save->GetInstanceId(), itr->second.perm ? "yes" : "no",
save->GetDifficulty(), save->CanReset() ? "yes" : "no", timeleft.c_str());
}
else
PSendSysMessage("bound for a nonexistent map %u", itr->first);
player->UnbindInstance(itr, Difficulty(i));
++counter;
}
else
++itr;
}
}
PSendSysMessage("instances unbound: %d", counter);
return true;
}
bool ChatHandler::HandleInstanceStatsCommand(char* /*args*/)
{
PSendSysMessage("instances loaded: %d", sMapMgr.GetNumInstances());
PSendSysMessage("players in instances: %d", sMapMgr.GetNumPlayersInInstances());
uint32 numSaves, numBoundPlayers, numBoundGroups;
sMapPersistentStateMgr.GetStatistics(numSaves, numBoundPlayers, numBoundGroups);
PSendSysMessage("instance saves: %d", numSaves);
PSendSysMessage("players bound: %d", numBoundPlayers);
PSendSysMessage("groups bound: %d", numBoundGroups);
return true;
}
bool ChatHandler::HandleInstanceSaveDataCommand(char* /*args*/)
{
Player* pl = m_session->GetPlayer();
Map* map = pl->GetMap();
InstanceData* iData = map->GetInstanceData();
if (!iData)
{
PSendSysMessage("Map has no instance data.");
SetSentErrorMessage(true);
return false;
}
iData->SaveToDB();
return true;
}
/// Display the list of GMs
bool ChatHandler::HandleGMListFullCommand(char* /*args*/)
{
///- Get the accounts with GM Level >0
QueryResult* result = LoginDatabase.Query("SELECT username,gmlevel FROM account WHERE gmlevel > 0");
if (result)
{
SendSysMessage(LANG_GMLIST);
SendSysMessage("========================");
SendSysMessage(LANG_GMLIST_HEADER);
SendSysMessage("========================");
///- Circle through them. Display username and GM level
do
{
Field* fields = result->Fetch();
PSendSysMessage("|%15s|%6s|", fields[0].GetString(), fields[1].GetString());
}
while (result->NextRow());
PSendSysMessage("========================");
delete result;
}
else
{ PSendSysMessage(LANG_GMLIST_EMPTY); }
return true;
}
/// Define the 'Message of the day' for the realm
bool ChatHandler::HandleServerSetMotdCommand(char* args)
{
sWorld.SetMotd(args);
PSendSysMessage(LANG_MOTD_NEW, args);
return true;
}
bool ChatHandler::ShowPlayerListHelper(QueryResult* result, uint32* limit, bool title, bool error)
{
if (!result)
{
if (error)
{
PSendSysMessage(LANG_NO_PLAYERS_FOUND);
SetSentErrorMessage(true);
}
return false;
}
if (!m_session && title)
{
SendSysMessage(LANG_CHARACTERS_LIST_BAR);
SendSysMessage(LANG_CHARACTERS_LIST_HEADER);
SendSysMessage(LANG_CHARACTERS_LIST_BAR);
}
if (result)
{
///- Circle through them. Display username and GM level
do
{
// check limit
if (limit)
{
if (*limit == 0)
{ break; }
--*limit;
}
Field* fields = result->Fetch();
uint32 guid = fields[0].GetUInt32();
std::string name = fields[1].GetCppString();
uint8 race = fields[2].GetUInt8();
uint8 class_ = fields[3].GetUInt8();
uint32 level = fields[4].GetUInt32();
ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(race);
ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(class_);
char const* race_name = raceEntry ? raceEntry->name[GetSessionDbcLocale()] : "<?>";
char const* class_name = classEntry ? classEntry->name[GetSessionDbcLocale()] : "<?>";
if (!m_session)
{ PSendSysMessage(LANG_CHARACTERS_LIST_LINE_CONSOLE, guid, name.c_str(), race_name, class_name, level); }
else
{ PSendSysMessage(LANG_CHARACTERS_LIST_LINE_CHAT, guid, name.c_str(), name.c_str(), race_name, class_name, level); }
}
while (result->NextRow());
delete result;
}
if (!m_session)
{ SendSysMessage(LANG_CHARACTERS_LIST_BAR); }
return true;
}
/// Output list of character for account
bool ChatHandler::HandleAccountCharactersCommand(char* args)
{
///- Get the command line arguments
std::string account_name;
Player* target = NULL; // only for triggering use targeted player account
uint32 account_id = ExtractAccountId(&args, &account_name, &target);
if (!account_id)
{ return false; }
///- Get the characters for account id
QueryResult* result = CharacterDatabase.PQuery("SELECT guid, name, race, class, level FROM characters WHERE account = %u", account_id);
return ShowPlayerListHelper(result);
}
/// Set/Unset the expansion level for an account
bool ChatHandler::HandleAccountSetAddonCommand(char* args)
{
///- Get the command line arguments
char* accountStr = ExtractOptNotLastArg(&args);
std::string account_name;
uint32 account_id = ExtractAccountId(&accountStr, &account_name);
if (!account_id)
{ return false; }
// Let set addon state only for lesser (strong) security level
// or to self account
if (GetAccountId() && GetAccountId() != account_id &&
HasLowerSecurityAccount(NULL, account_id, true))
{ return false; }
uint32 lev;
if (!ExtractUInt32(&args, lev))
{ return false; }
// No SQL injection
LoginDatabase.PExecute("UPDATE account SET expansion = '%u' WHERE id = '%u'", lev, account_id);
PSendSysMessage(LANG_ACCOUNT_SETADDON, account_name.c_str(), account_id, lev);
return true;
}
bool ChatHandler::HandleSendMailHelper(MailDraft& draft, char* args)
{
// format: "subject text" "mail text"
char* msgSubject = ExtractQuotedArg(&args);
if (!msgSubject)
{ return false; }
char* msgText = ExtractQuotedArg(&args);
if (!msgText)
{ return false; }
// msgSubject, msgText isn't NUL after prev. check
draft.SetSubjectAndBody(msgSubject, msgText);
return true;
}
bool ChatHandler::HandleSendMassMailCommand(char* args)
{
// format: raceMask "subject text" "mail text"
uint32 raceMask = 0;
char const* name = NULL;
if (!ExtractRaceMask(&args, raceMask, &name))
{ return false; }
// need dynamic object because it trasfered to mass mailer
MailDraft* draft = new MailDraft;
// fill mail
if (!HandleSendMailHelper(*draft, args))
{
delete draft;
return false;
}
// from console show nonexistent sender
MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
sMassMailMgr.AddMassMailTask(draft, sender, raceMask);
PSendSysMessage(LANG_MAIL_SENT, name);
return true;
}
bool ChatHandler::HandleSendItemsHelper(MailDraft& draft, char* args)
{
// format: "subject text" "mail text" item1[:count1] item2[:count2] ... item12[:count12]
char* msgSubject = ExtractQuotedArg(&args);
if (!msgSubject)
{ return false; }
char* msgText = ExtractQuotedArg(&args);
if (!msgText)
{ return false; }
// extract items
typedef std::pair<uint32, uint32> ItemPair;
typedef std::list< ItemPair > ItemPairs;
ItemPairs items;
// get from tail next item str
while (char* itemStr = ExtractArg(&args))
{
// parse item str
uint32 item_id = 0;
uint32 item_count = 1;
if (sscanf(itemStr, "%u:%u", &item_id, &item_count) != 2)
if (sscanf(itemStr, "%u", &item_id) != 1)
{ return false; }
if (!item_id)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
ItemPrototype const* item_proto = ObjectMgr::GetItemPrototype(item_id);
if (!item_proto)
{
PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
SetSentErrorMessage(true);
return false;
}
if (item_count < 1 || (item_proto->MaxCount > 0 && item_count > uint32(item_proto->MaxCount)))
{
PSendSysMessage(LANG_COMMAND_INVALID_ITEM_COUNT, item_count, item_id);
SetSentErrorMessage(true);
return false;
}
while (item_count > item_proto->GetMaxStackSize())
{
items.push_back(ItemPair(item_id, item_proto->GetMaxStackSize()));
item_count -= item_proto->GetMaxStackSize();
}
items.push_back(ItemPair(item_id, item_count));
if (items.size() > MAX_MAIL_ITEMS)
{
PSendSysMessage(LANG_COMMAND_MAIL_ITEMS_LIMIT, MAX_MAIL_ITEMS);
SetSentErrorMessage(true);
return false;
}
}
// fill mail
draft.SetSubjectAndBody(msgSubject, msgText);
for (ItemPairs::const_iterator itr = items.begin(); itr != items.end(); ++itr)
{
if (Item* item = Item::CreateItem(itr->first, itr->second, m_session ? m_session->GetPlayer() : 0))
{
item->SaveToDB(); // save for prevent lost at next mail load, if send fail then item will deleted
draft.AddItem(item);
}
}
return true;
}
bool ChatHandler::HandleSendItemsCommand(char* args)
{
// format: name "subject text" "mail text" item1[:count1] item2[:count2] ... item12[:count12]
Player* receiver;
ObjectGuid receiver_guid;
std::string receiver_name;
if (!ExtractPlayerTarget(&args, &receiver, &receiver_guid, &receiver_name))
{ return false; }
MailDraft draft;
// fill mail
if (!HandleSendItemsHelper(draft, args))
{ return false; }
// from console show nonexistent sender
MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
draft.SendMailTo(MailReceiver(receiver, receiver_guid), sender);
std::string nameLink = playerLink(receiver_name);
PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
return true;
}
bool ChatHandler::HandleSendMassItemsCommand(char* args)
{
// format: racemask "subject text" "mail text" item1[:count1] item2[:count2] ... item12[:count12]
uint32 raceMask = 0;
char const* name = NULL;
if (!ExtractRaceMask(&args, raceMask, &name))
{ return false; }
// need dynamic object because it trasfered to mass mailer
MailDraft* draft = new MailDraft;
// fill mail
if (!HandleSendItemsHelper(*draft, args))
{
delete draft;
return false;
}
// from console show nonexistent sender
MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
sMassMailMgr.AddMassMailTask(draft, sender, raceMask);
PSendSysMessage(LANG_MAIL_SENT, name);
return true;
}
bool ChatHandler::HandleSendMoneyHelper(MailDraft& draft, char* args)
{
/// format: "subject text" "mail text" money
char* msgSubject = ExtractQuotedArg(&args);
if (!msgSubject)
{ return false; }
char* msgText = ExtractQuotedArg(&args);
if (!msgText)
{ return false; }
uint32 money;
if (!ExtractUInt32(&args, money))
{ return false; }
if (money <= 0)
{ return false; }
// msgSubject, msgText isn't NUL after prev. check
draft.SetSubjectAndBody(msgSubject, msgText).SetMoney(money);
return true;
}
bool ChatHandler::HandleSendMoneyCommand(char* args)
{
/// format: name "subject text" "mail text" money
Player* receiver;
ObjectGuid receiver_guid;
std::string receiver_name;
if (!ExtractPlayerTarget(&args, &receiver, &receiver_guid, &receiver_name))
{ return false; }
MailDraft draft;
// fill mail
if (!HandleSendMoneyHelper(draft, args))
{ return false; }
// from console show nonexistent sender
MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
draft.SendMailTo(MailReceiver(receiver, receiver_guid), sender);
std::string nameLink = playerLink(receiver_name);
PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
return true;
}
bool ChatHandler::HandleSendMassMoneyCommand(char* args)
{
/// format: raceMask "subject text" "mail text" money
uint32 raceMask = 0;
char const* name = NULL;
if (!ExtractRaceMask(&args, raceMask, &name))
{ return false; }
// need dynamic object because it trasfered to mass mailer
MailDraft* draft = new MailDraft;
// fill mail
if (!HandleSendMoneyHelper(*draft, args))
{
delete draft;
return false;
}
// from console show nonexistent sender
MailSender sender(MAIL_NORMAL, m_session ? m_session->GetPlayer()->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
sMassMailMgr.AddMassMailTask(draft, sender, raceMask);
PSendSysMessage(LANG_MAIL_SENT, name);
return true;
}
/// Send a message to a player in game
bool ChatHandler::HandleSendMessageCommand(char* args)
{
///- Find the player
Player* rPlayer;
if (!ExtractPlayerTarget(&args, &rPlayer))
{ return false; }
///- message
if (!*args)
{ return false; }
WorldSession* rPlayerSession = rPlayer->GetSession();
///- Check that he is not logging out.
if (rPlayerSession->isLogingOut())
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
///- Send the message
// Use SendAreaTriggerMessage for fastest delivery.
rPlayerSession->SendAreaTriggerMessage("%s", args);
rPlayerSession->SendAreaTriggerMessage("|cffff0000[Message from administrator]:|r");
// Confirmation message
std::string nameLink = GetNameLink(rPlayer);
PSendSysMessage(LANG_SENDMESSAGE, nameLink.c_str(), args);
return true;
}
bool ChatHandler::HandleFlushArenaPointsCommand(char* /*args*/)
{
sBattleGroundMgr.DistributeArenaPoints();
return true;
}
bool ChatHandler::HandleModifyGenderCommand(char* args)
{
if (!*args)
{ return false; }
Player* player = getSelectedPlayer();
if (!player)
{
PSendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
PlayerInfo const* info = sObjectMgr.GetPlayerInfo(player->getRace(), player->getClass());
if (!info)
{ return false; }
char* gender_str = args;
int gender_len = strlen(gender_str);
Gender gender;
if (!strncmp(gender_str, "male", gender_len)) // MALE
{
if (player->getGender() == GENDER_MALE)
{ return true; }
gender = GENDER_MALE;
}
else if (!strncmp(gender_str, "female", gender_len)) // FEMALE
{
if (player->getGender() == GENDER_FEMALE)
{ return true; }
gender = GENDER_FEMALE;
}
else
{
SendSysMessage(LANG_MUST_MALE_OR_FEMALE);
SetSentErrorMessage(true);
return false;
}
// Set gender
player->SetByteValue(UNIT_FIELD_BYTES_0, 2, gender);
player->SetUInt16Value(PLAYER_BYTES_3, 0, uint16(gender) | (player->GetDrunkValue() & 0xFFFE));
// Change display ID
player->InitDisplayIds();
char const* gender_full = gender ? "female" : "male";
PSendSysMessage(LANG_YOU_CHANGE_GENDER, player->GetName(), gender_full);
if (needReportToTarget(player))
{ ChatHandler(player).PSendSysMessage(LANG_YOUR_GENDER_CHANGED, gender_full, GetNameLink().c_str()); }
return true;
}
bool ChatHandler::HandleShowGearScoreCommand(char* args)
{
Player* player = getSelectedPlayer();
if (!player)
{
PSendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
uint32 withBags, withBank;
if (!ExtractOptUInt32(&args, withBags, 1))
return false;
if (!ExtractOptUInt32(&args, withBank, 0))
return false;
// always recalculate gear score for display
player->ResetCachedGearScore();
uint32 gearScore = player->GetEquipGearScore(withBags != 0, withBank != 0);
PSendSysMessage(LANG_GEARSCORE, GetNameLink(player).c_str(), gearScore);
return true;
}
bool ChatHandler::HandleMmap(char* args)
{
bool on;
if (ExtractOnOff(&args, on))
{
if (on)
{
sWorld.setConfig(CONFIG_BOOL_MMAP_ENABLED, true);
SendSysMessage("WORLD: mmaps are now ENABLED (individual map settings still in effect)");
}
else
{
sWorld.setConfig(CONFIG_BOOL_MMAP_ENABLED, false);
SendSysMessage("WORLD: mmaps are now DISABLED");
}
return true;
}
on = sWorld.getConfig(CONFIG_BOOL_MMAP_ENABLED);
PSendSysMessage("mmaps are %sabled", on ? "en" : "dis");
return true;
}
bool ChatHandler::HandleMmapTestArea(char* args)
{
float radius = 40.0f;
ExtractFloat(&args, radius);
std::list<Creature*> creatureList;
MaNGOS::AnyUnitInObjectRangeCheck go_check(m_session->GetPlayer(), radius);
MaNGOS::CreatureListSearcher<MaNGOS::AnyUnitInObjectRangeCheck> go_search(creatureList, go_check);
// Get Creatures
Cell::VisitGridObjects(m_session->GetPlayer(), go_search, radius);
if (!creatureList.empty())
{
PSendSysMessage("Found " SIZEFMTD " Creatures.", creatureList.size());
uint32 paths = 0;
uint32 uStartTime = WorldTimer::getMSTime();
float gx, gy, gz;
m_session->GetPlayer()->GetPosition(gx, gy, gz);
for (std::list<Creature*>::iterator itr = creatureList.begin(); itr != creatureList.end(); ++itr)
{
PathFinder path(*itr);
path.calculate(gx, gy, gz);
++paths;
}
uint32 uPathLoadTime = WorldTimer::getMSTimeDiff(uStartTime, WorldTimer::getMSTime());
PSendSysMessage("Generated %i paths in %i ms", paths, uPathLoadTime);
}
else
{
PSendSysMessage("No creatures in %f yard range.", radius);
}
return true;
}
// use ".mmap testheight 10" selecting any creature/player
bool ChatHandler::HandleMmapTestHeight(char* args)
{
float radius = 0.0f;
ExtractFloat(&args, radius);
if (radius > 40.0f)
radius = 40.0f;
Unit* unit = getSelectedUnit();
Player* player = m_session->GetPlayer();
if (!unit)
unit = player;
if (unit->GetTypeId() == TYPEID_UNIT)
{
if (radius < 0.1f)
radius = static_cast<Creature*>(unit)->GetRespawnRadius();
}
else
{
if (unit->GetTypeId() != TYPEID_PLAYER)
{
PSendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
return false;
}
}
if (radius < 0.1f)
{
PSendSysMessage("Provided spawn radius for %s is too small. Using 5.0f instead.", unit->GetGuidStr().c_str());
radius = 5.0f;
}
float gx, gy, gz;
unit->GetPosition(gx, gy, gz);
Creature* summoned = unit->SummonCreature(VISUAL_WAYPOINT, gx, gy, gz + 0.5f, 0, TEMPSUMMON_TIMED_DESPAWN, 20000);
summoned->CastSpell(summoned, 8599, false);
uint32 tries = 1;
uint32 successes = 0;
uint32 startTime = WorldTimer::getMSTime();
for (; tries < 500; ++tries)
{
unit->GetPosition(gx, gy, gz);
if (unit->GetMap()->GetReachableRandomPosition(unit, gx, gy, gz, radius))
{
unit->SummonCreature(VISUAL_WAYPOINT, gx, gy, gz, 0, TEMPSUMMON_TIMED_DESPAWN, 15000);
++successes;
if (successes >= 100)
break;
}
}
uint32 genTime = WorldTimer::getMSTimeDiff(startTime, WorldTimer::getMSTime());
PSendSysMessage("Generated %u valid points for %u try in %ums.", successes, tries, genTime);
return true;
}
bool ChatHandler::HandleServerResetAllRaidCommand(char* args)
{
PSendSysMessage("Global raid instances reset, all players in raid instances will be teleported to homebind!");
sMapPersistentStateMgr.GetScheduler().ResetAllRaid();
return true;
}
| 30.282516 | 249 | 0.609542 | tbayart |
b43b885f4f8a57b490612b28ca9653a7e08aa96f | 9,255 | cpp | C++ | src/graphic/oni-graphic-renderer-ogl-quad.cpp | sina-/granite | 95b873bc545cd4925b5cea8c632a82f2d815be6e | [
"MIT"
] | 2 | 2019-08-01T09:18:49.000Z | 2020-03-26T05:59:52.000Z | src/graphic/oni-graphic-renderer-ogl-quad.cpp | sina-/granite | 95b873bc545cd4925b5cea8c632a82f2d815be6e | [
"MIT"
] | null | null | null | src/graphic/oni-graphic-renderer-ogl-quad.cpp | sina-/granite | 95b873bc545cd4925b5cea8c632a82f2d815be6e | [
"MIT"
] | 1 | 2020-03-26T05:59:53.000Z | 2020-03-26T05:59:53.000Z | #include <oni-core/graphic/oni-graphic-renderer-ogl-quad.h>
#include <cassert>
#include <GL/glew.h>
#include <oni-core/graphic/buffer/oni-graphic-buffer-data.h>
#include <oni-core/graphic/buffer/oni-graphic-index-buffer.h>
#include <oni-core/graphic/buffer/oni-graphic-frame-buffer.h>
#include <oni-core/graphic/buffer/oni-graphic-vertex-array.h>
#include <oni-core/graphic/oni-graphic-shader.h>
#include <oni-core/component/oni-component-geometry.h>
#include <oni-core/component/oni-component-visual.h>
#include <oni-core/math/oni-math-function.h>
namespace oni {
Renderer_OpenGL_Quad::Renderer_OpenGL_Quad(oniGLsizei maxPrimitiveCount,
TextureManager &tm) :
Renderer_OpenGL(PrimitiveType::TRIANGLES, tm), mMaxPrimitiveCount(maxPrimitiveCount) {
mMaxIndicesCount = mMaxPrimitiveCount * 6;
oniGLsizei vertexSize = sizeof(QuadVertex);
oniGLsizei primitiveSize = vertexSize * 4;
assert(mMaxIndicesCount < std::numeric_limits<i32>::max());
oniGLsizei maxBufferSize{primitiveSize * mMaxPrimitiveCount};
auto vertShader = std::string_view("oni-resources/shaders/quad.vert");
auto geomShader = std::string_view("");
auto fragShader = std::string_view("oni-resources/shaders/quad.frag");
mShader = std::make_unique<Shader>(vertShader,
geomShader,
fragShader);
auto program = mShader->getProgram();
auto positionIndex = glGetAttribLocation(program, "position");
auto colorIndex = glGetAttribLocation(program, "color");
auto uvIndex = glGetAttribLocation(program, "uv");
auto samplerFrontIndex = glGetAttribLocation(program, "samplerFront");
auto samplerBackIndex = glGetAttribLocation(program, "samplerBack");
if (positionIndex == -1 || uvIndex == -1 || colorIndex == -1 ||
samplerFrontIndex == -1 || samplerBackIndex == -1) {
assert(false);
}
BufferStructure samplerFront;
samplerFront.index = static_cast<oniGLuint>(samplerFrontIndex);
samplerFront.componentCount = 1;
samplerFront.componentType = GL_FLOAT;
samplerFront.normalized = GL_FALSE;
samplerFront.stride = vertexSize;
samplerFront.offset = static_cast<const oniGLvoid *>(nullptr);
BufferStructure samplerBack;
samplerBack.index = static_cast<oniGLuint>(samplerBackIndex);
samplerBack.componentCount = 1;
samplerBack.componentType = GL_FLOAT;
samplerBack.normalized = GL_FALSE;
samplerBack.stride = vertexSize;
samplerBack.offset = reinterpret_cast<const oniGLvoid *>(offsetof(QuadVertex,
samplerBack));
BufferStructure color;
color.index = static_cast<oniGLuint>(colorIndex);
color.componentCount = 4;
color.componentType = GL_FLOAT;
color.normalized = GL_TRUE;
color.stride = vertexSize;
color.offset = reinterpret_cast<const oniGLvoid *>(offsetof(QuadVertex, color));
BufferStructure uv;
uv.index = static_cast<oniGLuint>(uvIndex);
uv.componentCount = 2;
uv.componentType = GL_FLOAT;
uv.normalized = GL_TRUE;
uv.stride = vertexSize;
uv.offset = reinterpret_cast<const oniGLvoid *>(offsetof(QuadVertex, uv));
BufferStructure position;
position.index = static_cast<oniGLuint>(positionIndex);
position.componentCount = 3;
position.componentType = GL_FLOAT;
position.normalized = GL_FALSE;
position.stride = vertexSize;
position.offset = reinterpret_cast<const oniGLvoid *>(offsetof(QuadVertex, pos));
std::vector<BufferStructure> bufferStructures;
bufferStructures.push_back(samplerFront);
bufferStructures.push_back(samplerBack);
bufferStructures.push_back(color);
bufferStructures.push_back(uv);
bufferStructures.push_back(position);
mVertexArray = std::make_unique<VertexArray>(bufferStructures, maxBufferSize);
if (mMaxIndicesCount > mMaxPrimitiveCount) {
mIndexBuffer = std::make_unique<IndexBuffer>(mMaxIndicesCount);
}
std::vector<GLint> samplers;
for (i8 i = 0; i < mMaxNumTextureSamplers; ++i) {
samplers.push_back(i);
}
mShader->enable();
mShader->setUniformiv("samplers", samplers);
mShader->disable();
}
Renderer_OpenGL_Quad::~Renderer_OpenGL_Quad() = default;
void
Renderer_OpenGL_Quad::submit(const Quad &quad,
const Color &color,
const Texture *texture) {
assert(mIndexCount + 6 < mMaxIndicesCount);
auto buffer = static_cast<QuadVertex *>(mBuffer);
auto samplerFront = -1.f;
auto samplerBack = -1.f;
auto uv0 = vec2{};
auto uv1 = vec2{};
auto uv2 = vec2{};
auto uv3 = vec2{};
if (texture) {
samplerFront = getSamplerID(texture->id);
uv0 = texture->uv.values[0];
uv1 = texture->uv.values[1];
uv2 = texture->uv.values[2];
uv3 = texture->uv.values[3];
}
auto c = color.rgba();
// a.
buffer->pos = quad.a.value;
buffer->color = c;
buffer->uv = uv0;
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
// b.
buffer->pos = quad.b.value;
buffer->color = c;
buffer->uv = uv1;
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
// c.
buffer->pos = quad.c.value;
buffer->color = c;
buffer->uv = uv2;
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
// d.
buffer->pos = quad.d.value;
buffer->color = c;
buffer->uv = uv3;
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
// Update the mBuffer to point to the head.
mBuffer = static_cast<void *>(buffer);
// +6 as there are 6 vertices that makes up two adjacent triangles but those triangles are
// defined by 4 vertices only.
/**
* 1 +---+ 2
* | /|
* |/ |
* 0 +---+ 3
**/
mIndexCount += 6;
}
void
Renderer_OpenGL_Quad::submit(const Quad &quad,
const Color &color,
const Texture &front,
const Texture &back) {
assert(mIndexCount + 6 < mMaxIndicesCount);
assert(front.id);
assert(back.id);
assert(almost_Equal(front.uv.values[0].x, back.uv.values[0].x));
assert(almost_Equal(front.uv.values[1].x, back.uv.values[1].x));
assert(almost_Equal(front.uv.values[2].x, back.uv.values[2].x));
assert(almost_Equal(front.uv.values[3].x, back.uv.values[3].x));
assert(almost_Equal(front.uv.values[0].y, back.uv.values[0].y));
assert(almost_Equal(front.uv.values[1].y, back.uv.values[1].y));
assert(almost_Equal(front.uv.values[2].y, back.uv.values[2].y));
assert(almost_Equal(front.uv.values[3].y, back.uv.values[3].y));
auto buffer = static_cast<QuadVertex *>(mBuffer);
auto samplerFront = getSamplerID(front.id);
auto samplerBack = getSamplerID(back.id);
auto c = color.rgba();
buffer->pos = quad.a.value;
buffer->color = c;
buffer->uv = front.uv.values[0];
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
buffer->pos = quad.b.value;
buffer->color = c;
buffer->uv = front.uv.values[1];
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
buffer->pos = quad.c.value;
buffer->color = c;
buffer->uv = front.uv.values[2];
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
buffer->pos = quad.d.value;
buffer->color = c;
buffer->uv = front.uv.values[3];
buffer->samplerFront = samplerFront;
buffer->samplerBack = samplerBack;
++buffer;
mBuffer = static_cast<void *>(buffer);
mIndexCount += 6;
}
void
Renderer_OpenGL_Quad::submit(const Renderable &renderable) {
// TODO: Implement
assert(false);
}
void
Renderer_OpenGL_Quad::enableShader(const RenderSpec &spec) {
mShader->enable();
mShader->setUniformMat4("model", spec.model);
mShader->setUniformMat4("view", spec.view);
mShader->setUniformMat4("proj", spec.proj);
}
oniGLsizei
Renderer_OpenGL_Quad::getIndexCount() {
return mIndexCount;
}
void
Renderer_OpenGL_Quad::resetIndexCount() {
mIndexCount = 0;
}
} | 33.532609 | 98 | 0.596002 | sina- |
b43d3e527520ce9b211eda35514afe356721df04 | 760 | cpp | C++ | src/powercycle.cpp | raghu-veer/powercycle-mgr | 955e806538560575078aaee261149d8b04ee07f3 | [
"MIT"
] | null | null | null | src/powercycle.cpp | raghu-veer/powercycle-mgr | 955e806538560575078aaee261149d8b04ee07f3 | [
"MIT"
] | null | null | null | src/powercycle.cpp | raghu-veer/powercycle-mgr | 955e806538560575078aaee261149d8b04ee07f3 | [
"MIT"
] | null | null | null | #include <cstdlib>
#include <cstdint>
#include <string>
#include <vector>
#include <chrono>
#include <ctime>
#include <fstream>
#include <unistd.h>
#include <sys/reboot.h>
#include "powercycle.hpp"
Powercycle::Powercycle(const uint32_t& wakeupTime) :
wakeupTime_(wakeupTime)
{
execute();
}
void Powercycle::execute()
{
invokeRTC();
shutdown();
}
void Powercycle::invokeRTC()
{
time_t currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::ofstream rtcStream;
rtcStream.open(RTC_WAKEALARM);
rtcStream << time(¤tTime) + (wakeupTime_ * SECONDS);
rtcStream.close();
}
/* using reboot(2) to shutdown immediately, see man reboot(2) */
void Powercycle::shutdown()
{
reboot(RB_POWER_OFF);
}
| 19.487179 | 94 | 0.703947 | raghu-veer |
b43eacc0c960cc5807ad6e737a95394d19b99747 | 47,347 | cpp | C++ | src/qsa/src/engine/qsclass.cpp | hackbinary/pdfedit | 5efb58265d0b86c2786d7b218aa0d6f895b926d3 | [
"CECILL-B"
] | 13 | 2015-10-15T01:26:37.000Z | 2019-11-18T21:50:46.000Z | src/qsa/src/engine/qsclass.cpp | mmoselhy/PDF-X | b72597bbb0c6c86d99e44cf18f7b46d5175a7bfa | [
"CECILL-B"
] | 1 | 2020-03-28T23:06:53.000Z | 2020-04-08T03:24:06.000Z | src/qsa/src/engine/qsclass.cpp | mmoselhy/PDF-X | b72597bbb0c6c86d99e44cf18f7b46d5175a7bfa | [
"CECILL-B"
] | 14 | 2016-01-31T10:54:56.000Z | 2020-08-31T11:08:42.000Z | /****************************************************************************
** $Id$
**
** Copyright (C) 2001-2006 Trolltech AS. All rights reserved.
**
** This file is part of the Qt Script for Applications framework (QSA).
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding a valid Qt Script for Applications license may use
** this file in accordance with the Qt Script for Applications License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email [email protected] for
** information about QSA Commercial License Agreements.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact [email protected] if any conditions of this licensing are
** not clear to you.
**
*****************************************************************************/
#include "qsclass.h"
#include "qsenv.h"
#include "qsoperations.h"
#include "qstypes.h"
#include "qsnodes.h"
#include "qsfuncref.h"
#include <stdlib.h>
#if defined(Q_OS_WIN32)
#include <qt_windows.h>
#endif
using namespace QS;
QSClass::QSClass( QSEnv *e, int a )
: en( e ),
bclass( 0 ),
encClass( 0 ),
attrs( a )
{
Q_ASSERT( e );
init();
}
QSClass::QSClass( QSClass *b, int a )
: bclass( b ),
encClass( 0 ),
attrs( a )
{
Q_ASSERT( b && b->env() );
en = b->env();
init();
}
QSClass::~QSClass()
{
}
void QSClass::clear()
{
for (QSMemberMap::ConstIterator it = mmap->begin(); it!=mmap->end(); ++it) {
if ((*it).type() == QSMember::ScriptFunction) {
if ((*it).scriptFunction->deref()) {
delete (*it).scriptFunction;
}
}
}
delete mmap;
mmap = 0;
staticMembers.clear();
}
void QSClass::init()
{
mmap = new QSMemberMap();
numVars = base() ? base()->numVariables() : 0;
numStaticVars = 0;
en->registerClass( this );
}
/*!
Checks if the two objects are equal. Returns positive if equal, 0 if
not equal and negative if the class is unable to determine.
*/
QSEqualsResult QSClass::isEqual( const QSObject &a, const QSObject &/*b*/ ) const
{
Q_ASSERT( a.isA( this ) );
// qDebug( "QSClass::isEqual( %s, %s )",
// a.typeName().ascii(), b.typeName().ascii() );
return EqualsUndefined;
}
/*!
Checks if two objects are strictly equal, meaning that they are
exactly the same object.
*/
QSEqualsResult QSClass::isStrictEqual( const QSObject &a, const QSObject &b ) const
{
Q_ASSERT( a.isA( this ) );
if ( a.objectType() != b.objectType() )
return EqualsNotEqual;
if ( a.isUndefined() || a.isNull() )
return EqualsIsEqual;
if ( a.isNumber() ) {
double doubA = a.toNumber();
if ( isNaN( doubA ) )
return EqualsNotEqual;
double doubB = b.toNumber();
if ( isNaN( doubB ) )
return EqualsNotEqual;
if ( doubA == doubB
|| ( doubA==0 && doubB==-0 )
|| ( doubA==-0 && doubB==0 ) )
return EqualsIsEqual;
return EqualsNotEqual;
} else if ( a.isString() ) {
return (QSEqualsResult) (a.toString() == b.toString()
|| (a.sVal().isEmpty() && b.sVal().isEmpty()));
} else if ( a.isBoolean() ) {
return ( QSEqualsResult ) ( a.toBoolean() == b.toBoolean() );
}
return ( QSEqualsResult ) ( a.shVal() == b.shVal() );
}
QSCompareResult QSClass::compare( const QSObject &a, const QSObject &b ) const
{
// qDebug( "\nQSClass::compare" );
// qDebug( "a: %s\nb: %s", a.toString().latin1(), b.toString().latin1() );
QSObject primA = a.toPrimitive( env()->numberClass() );
QSObject primB = b.toPrimitive( env()->numberClass() );
if( primA.isString() && primB.isString() ) {
QString strA = primA.toString();
QString strB = primB.toString();
if (strA.isEmpty() && strB.isEmpty())
return CompareEqual;
int ret = QString::compare(strA, strB);
if( ret==0 )
return CompareEqual;
else if( ret<0 )
return CompareLess;
else
return CompareGreater;
}
double doubA = primA.toNumber();
double doubB = primB.toNumber();
// qDebug( "a=%f, b=%f", doubA, doubB );
if( isNaN( doubA ) || isNaN( doubB ) ) {
return CompareUndefined;
}
// ### +0 vs -0 cases...
if( doubA==doubB ) {
return CompareEqual;
} else if( doubA < doubB ) {
return CompareLess;
} else {
return CompareGreater;
}
return CompareUndefined;
}
void QSClass::finalize()
{
#if 0 // ### required to avoid double deletions
QSObjectList::iterator it = staticMembers.begin();
QSObjectList::iterator end = staticMembers.end();
while ( it != end ) {
(*it).invalidate();
++it;
}
#else
staticMembers.clear();
#endif
for (QSMemberMap::ConstIterator it = mmap->begin(); it!=mmap->end(); ++it)
if ((*it).type() == QSMember::ScriptFunction) {
if ((*it).scriptFunction->scopeDefinition())
(*it).scriptFunction->scopeDefinition()->setFunctionBodyNode(0);
(*it).scriptFunction->setScopeDefinition(0);
}
}
QSClassClass* QSClass::asClass() const
{
return name() == QString::fromLatin1("Class") ? (QSClassClass*)this : 0;
}
QSObject QSClass::execute( const QSObject *, QSObject *, const QSList & ) const
{
throwError( TypeError, QString::fromLatin1("Cannot invoke objects of type %1 as function").arg(name()) );
return createUndefined();
}
/*!
Returns TRUE if this class is a subclass of \c; FALSE otherwise.
A class is defined to be a subclass of itself.
*/
bool QSClass::inherits( const QSClass *c ) const
{
const QSClass *b = this;
while ( b && b != c )
b = b->base();
return b == c;
}
/*!
* Mark \a o and its sub-properties as referenced. This is used
* for the mark & sweep garbage collection.
*
* The default implementation does nothing but you should reimplement
* this function if objects of this class contain other objects
* or references to them.
*/
void QSClass::mark( QSObject * /*o*/ ) const
{
// do nothing
}
void QSClass::ref( QSObject * /*o*/ ) const
{
}
void QSClass::deref( QSObject * /*o*/ ) const
{
}
/*!
* Returns \a obj converted to a boolean value.
*
* The default implementation returns TRUE.
*/
bool QSClass::toBoolean( const QSObject * /*obj*/ ) const
{
return TRUE;
}
/*!
* Return \a obj converted to a floating point number; NaN if
* the conversion failed.
*
* The default implementation returns NaN.
*/
double QSClass::toNumber( const QSObject * ) const
{
return NaN;
}
/*!
* Return \a obj converted to a string.
*
* The default implementation returns "[object N]" where N is
* the name of this class as retrieved by name().
*/
QString QSClass::toString( const QSObject * ) const
{
return QString::fromLatin1("[object ") + name() + QString::fromLatin1("]");
}
QSObject QSClass::toPrimitive( const QSObject *obj,
const QSClass *preferred ) const
{
if( preferred != env()->numberClass() )
return createString( toString( obj ) );
else
return createNumber( toNumber( obj ) );
}
/*! Convert \a obj to an equivalent QVariant. The default implementation
returns in invalid QVariant which may also be the case where no mapping
for an equivalent type exists.
*/
QVariant QSClass::toVariant( const QSObject * /*obj*/, QVariant::Type ) const
{
// ### how about respecting the prefered type ?
return QVariant();
}
#if QS_MAX_STACK>0
static int debugStringRecursionDepth = 0;
#endif
QString QSClass::debugString( const QSObject *obj ) const
{
#if QS_MAX_STACK>0
if( ++debugStringRecursionDepth==QS_MAX_STACK ) {
Q_ASSERT( obj->isValid() );
obj->env()->throwError( RangeError,
QString::fromLatin1("Internal recursion level maxed out in: "
"QSArrayClass::joinInternal"), -1 );
--debugStringRecursionDepth;
return QString::null;
}
#endif
QString retVal = QString::null;
if ( obj->isPrimitive() ) {
retVal = toString( obj ) + QString::fromLatin1(":") + name();
} else {
QSMemberMap m = members( obj );
if ( m.isEmpty() ) {
retVal = toString( obj ) + QString::fromLatin1(":") + name();
} else {
QSMemberMap::ConstIterator it = m.begin();
retVal = "{";
for ( ;; ) {
QSObject p = env()->resolveValue( it.key() );
if ( !p.isValid() ) {
// ### should never happen (but sometimes does)
++it;
if ( it == m.end() )
break;
else
continue;
}
retVal += it.key() + QString::fromLatin1("=") + p.debugString();
++it;
if ( it == m.end() )
break;
else
retVal += QString::fromLatin1(",");
}
retVal += QString::fromLatin1("}:") + identifier();
}
}
#if QS_MAX_STACK>0
--debugStringRecursionDepth;
#endif
return retVal;
}
bool QSClass::deleteProperty( QSObject *, const QSMember & ) const
{
return FALSE;
}
/*!
Retrieves a pointer to the class member \a n; 0 if no such member exists.
*/
bool QSClass::member( const QSObject *, const QString &n, QSMember *m ) const
{
// qDebug( "QSClass::member() class = %s, name = %s", name().latin1(), n.latin1() );
Q_ASSERT( !n.isEmpty() );
Q_ASSERT( m );
Q_ASSERT( mmap );
QSMemberMap::Iterator it = mmap->find( n );
if( it == mmap->end() ) {
return FALSE;
} else {
*m = it.data();
return TRUE;
}
}
QSObject QSClass::fetchValue( const QSObject *objPtr,
const QSMember &mem ) const
{
// qDebug( "fetching from: " + identifier() + ", " + mem );
if( !mem.isReadable() ) {
qDebug( "QSClass:fetchValue() - not readable: %s", mem.name().latin1() );
return createUndefined();
}
if( mem.type()==QSMember::Variable ) {
if ( !mem.isStatic() ) {
QSInstanceData *data = (QSInstanceData*)objPtr->shVal();
if ( mem.idx >= data->size() ) {
// ### could throw error in member()
// qWarning( "QSClass::fetchValue: non-resized array access" );
return createUndefined();
}
QSObject * ptr = data->value( mem.idx );
if ( !ptr->isValid() ) {
// qWarning( "QSMember::fetch: Accessed uninitialized variable" );
return createUndefined();
}
return *ptr;
} else {
return staticMember( mem.idx );
}
} else if ( mem.isExecutable() ) {
return env()->funcRefClass()->createReference( *objPtr, mem );
}
return createUndefined();
}
void QSClass::write( QSObject *objPtr, const QSMember &mem,
const QSObject &val ) const
{
Q_ASSERT( mem.isWritable() );
if (mem.type() != QSMember::Variable) {
env()->throwError(ReferenceError,
QString::fromLatin1("Member '%1' cannot be overwritten in '%2'")
.arg(mem.name()).arg(name()));
return;
}
if ( mem.isWritable() && mem.type()==QSMember::Variable ) {
if ( !mem.isStatic() ) {
QSInstanceData *data = (QSInstanceData*)objPtr->shVal();
if ( mem.idx >= data->size() ) {
qWarning( "QSClass::write(), index=%d greater than array size=%d",
mem.idx, data->size() );
// ### could throw error in member()
return;
}
data->setValue( mem.idx, val );
} else {
QSClass * cl = (QSClass*) this;
cl->setStaticMember( mem.idx, val );
}
}
}
/*!
Only use for objPtr's that absolutly have QSInstanceData
*/
void QSClass::write( QSObject * objPtr, int index, const QSObject &val ) const
{
QSInstanceData *idata = (QSInstanceData*)objPtr->shVal();
idata->setValue( index, val );
}
void QSClass::setStaticMember( int idx, const QSObject &val )
{
Q_ASSERT( idx>=0 && idx<numStaticVars );
staticMembers[idx] = val;
}
QSObject QSClass::staticMember( int idx ) const
{
Q_ASSERT( idx>=0 && idx<numStaticVars );
return staticMembers[idx];
}
static bool compareScopes( const QSObject &a, const QSObject &b )
{
return a.objectType()==b.objectType() && a.shVal()==b.shVal();
}
QSObject QSClass::invoke( QSObject * objPtr, const QSMember &mem ) const
{
Q_ASSERT( mem.isExecutable() );
Q_ASSERT( objPtr->objectType() == this );
switch( mem.type() ) {
case QSMember::NativeFunction:
return (*mem.nativeFunction)( env() );
case QSMember::NativeVoidFunction:
(*mem.nativeVoidFunction)( env() );
return createUndefined();
case QSMember::NativeMemberFunction:
Q_ASSERT( !mem.isStatic() );
qWarning( "This should never be called!!" );
return createUndefined();
case QSMember::ScriptFunction:
{
Q_ASSERT( mem.scriptFunction );
const QSList *args = env()->arguments();
#ifdef QSDEBUGGER
Debugger *dbg = env()->engine()->debugger();
// arguments as string for call stack info
QString argStr = QString::fromLatin1("");
for ( int j = 0; j < args->size(); j++ ) {
if ( j > 0 )
argStr += QString::fromLatin1(", ");
QSObject a = args->at( j );
argStr += a.toString() + QString::fromLatin1(" : ") + a.typeName();
}
QString n = mem.scriptFunction->scopeDefinition()->identifier();
if( dbg )
dbg->callEvent( n, argStr );
// debugger has to be told that we are potentially
// jumping to script code in a different source unit
int oldSourceId = -1;
if ( dbg ) {
oldSourceId = dbg->sourceId();
dbg->setSourceId( mem.scriptFunction->sourceId() );
}
#endif
QSFunctionScopeClass *scopeDef = mem.scriptFunction->scopeDefinition();
// qDebug( "Calling function: " + scopeDef->identifier() );
// qDebug( "objPtr is: " + objPtr->objectType()->identifier() );
// qDebug( "currentScope is: " + env()->currentScope().objectType()->identifier() );
// env()->printScopeChain();
// Use invalid object for scopes that don't have variables..
QSObject scope = scopeDef->construct( *args );
QSObject returnValue;
if ( compareScopes( *objPtr, env()->currentScope() ) ) {
// qDebug( "Push scope type 1" );
env()->pushScope( scope );
returnValue = mem.scriptFunction->execute( env() );
env()->popScope();
} else if( objPtr->objectType()->enclosingClass()==env()->currentScope().objectType() ) {
// qDebug( "Push scope type 1b" );
env()->pushScope( *objPtr );
env()->pushScope( scope );
returnValue = mem.scriptFunction->execute( env() );
env()->popScope();
env()->popScope();
} else if ( objPtr->objectType()->enclosingClass() == 0 ) {
// qDebug( "Push scope type 1c" );
env()->pushScopeBlock();
env()->pushScope( env()->globalObject() );
env()->pushScope( *objPtr );
env()->pushScope( scope );
// env()->printScopeChain();
returnValue = mem.scriptFunction->execute( env() );
env()->popScopeBlock();
} else if ( env()->currentScope().objectType() == env()->globalObject().objectType() ) {
// object has an enclosing class, but current scope is only global
// qDebug( "Push scope type 1d" );
env()->pushScopeBlock();
env()->pushScope( env()->globalObject() );
env()->pushScope( *objPtr );
env()->pushScope( scope );
returnValue = mem.scriptFunction->execute( env() );
env()->popScopeBlock();
} else {
// qDebug( "Push scope type 2" );
// ### This loop is a duplicate of the one already done in resolvenode
ScopeChain chain = env()->scope();
ScopeChain::Iterator it = chain.begin();
bool pushObj = FALSE;
while( it!=chain.end() ) {
if( compareScopes( *it, *objPtr ) ) {
break;
} else if ( (*it).objectType() ==
objPtr->objectType()->enclosingClass() ) {
pushObj = TRUE;
break;
}
else {
it = chain.remove( it );
}
}
env()->pushScopeBlock();
while( chain.size()>0 ) {
env()->pushScope( chain.back() );
chain.pop_back();
}
if( pushObj ) env()->pushScope( *objPtr );
env()->pushScope( scope );
// env()->printScopeChain();
returnValue = mem.scriptFunction->execute( env() );
env()->popScopeBlock();
}
#ifdef QSDEBUGGER
if ( dbg )
dbg->returnEvent();
// restore previous source id
if (dbg)
dbg->setSourceId(oldSourceId);
#endif
return env()->isReturnValueMode() ? returnValue : createUndefined();
}
case QSMember::Variable: {
QSObject o = fetchValue( objPtr, mem );
if ( o.objectType()->valueType() == TypeClass )
return QSTypeClass::classValue(&o)->cast( *env()->arguments() );
qFatal( "QSClass::invoke: Unhandled variable type" );
break;
}
default:
qFatal( "QSClass::invoke: Unhandled switch case %d", mem.type() );
}
return createUndefined();
}
void QSClass::addFunctionMember( const QString &n, QSFunctionBodyNode * f, int attributes )
{
addMember( n, QSMember( f, attributes ), createUndefined() );
}
int QSClass::addVariableMember( const QString &n, int attributes )
{
addMember( n, QSMember( QSMember::Variable, attributes ), createUndefined() );
return attributes & AttributeStatic ? numStaticVars - 1 : numVars-1;
}
void QSClass::addStaticVariableMember( const QString &name, const QSObject &value, int attr )
{
addMember( name, QSMember( QSMember::Variable, attr | AttributeStatic ), value );
}
/*!
Add member \a member with name \a n to this class. \stVal contains the value
if the member is a static variable.
*/
void QSClass::addMember( const QString &n, const QSMember &member, const QSObject &stVal )
{
Q_ASSERT( !mmap->contains( n ) );
QSMember m = member;
m.setName( n );
m.setOwner( this );
switch (m.type()) {
case QSMember::Variable:
if( m.isStatic() ) {
m.setIndex( numStaticVars++ );
staticMembers.append( stVal );
} else {
m.setIndex( numVars++ );
}
break;
case QSMember::ScriptFunction:
m.scriptFunction->ref(); // Since it is stored by member.
break;
default:
break;
}
mmap->insert( n, m );
}
/* Factored out from replace member */
void QSClass::removeStaticVar( const QSMember &old )
{
staticMembers.remove( staticMembers.at(old.idx) );
QSMemberMap::iterator it = mmap->begin();
while( it!=mmap->end() ) {
QSMember &cur = *it;
if( cur.type()==QSMember::Variable && cur.isStatic() && cur.idx>old.idx )
cur.idx--;
it++;
}
numStaticVars--;
}
/* Factored out from replaceMember */
void QSClass::fillMemberVarIndex( QSMember *member )
{
if( !replacedVars.isEmpty() ) { // Reuse old varspace if possible.
member->idx = replacedVars[0];
replacedVars.pop_front();
} else {
member->idx = numVars++;
}
}
/*!
Replaces the member \name with \member. \stVal can contain the value if the
member is a static variable.
*/
void QSClass::replaceMember( const QString &name, QSMember *member,
const QSObject &stVal )
{
// qDebug( "QSClass::replaceMember(%s)", name.latin1() );
Q_ASSERT( mmap->contains( name ) );
QSMember old = *(mmap->find( name ));
QSMember &m = *member;
m.setName( name );
m.setOwner( this );
// Delete old function implementation.
if (old.type() == QSMember::ScriptFunction) {
if (old.scriptFunction->deref()) { // will delete
delete old.scriptFunction;
old.scriptFunction = 0;
} else {
if (old.scriptFunction->scopeDefinition())
old.scriptFunction->setScopeDefinition(0);
old.scriptFunction->setScopeDefinition(0);
}
}
// Ref new one...
if (m.type() == QSMember::ScriptFunction)
m.scriptFunction->ref();
if( old.type()==QSMember::Variable && m.type()==QSMember::Variable ) {
if( old.isStatic() == m.isStatic() ) { // both static or both nonstatic
m.idx = old.idx;
if( old.isStatic() ) // replace value if static
staticMembers[m.idx] = stVal;
} else if( old.isStatic() ) {
removeStaticVar( old );
fillMemberVarIndex( &m );
} else if( m.isStatic() ) {
m.idx = numStaticVars++;
staticMembers.append( stVal );
replacedVars.append( old.idx );
}
} else if( (old.type()==QSMember::ScriptFunction ||
old.type()==QSMember::NativeFunction ||
old.type()==QSMember::NativeMemberFunction) &&
(m.type()==QSMember::ScriptFunction ||
m.type()==QSMember::NativeFunction ||
m.type()==QSMember::NativeMemberFunction) ) {
// Replace only...
} else if ( old.type()==QSMember::Variable ) { // Variable -> function
if( old.isStatic() ) { // Delete and update member indexes
removeStaticVar( old );
} else { // Store index for reuse later.
replacedVars.append( old.idx );
}
} else if ( m.type()==QSMember::Variable ) {
if( m.isStatic() ) {
m.idx = numStaticVars++;
staticMembers.append( stVal );
} else {
fillMemberVarIndex( &m );
}
} else {
qFatal( "QSClass::replaceMember() -- Unhandled case" );
}
mmap->replace( name, m );
}
/*!
Deletes the member under name \name. If deletion was not possible, FALSE
is returned
*/
bool QSClass::deleteMember( const QString &name ) {
if( !mmap->contains( name ) ) {
return FALSE;
}
// ### What do we do about variable indexes??
mmap->remove( name );
return TRUE;
}
bool QSClass::hasProperty( const QSObject *obj,
const QString &p ) const
{
// standard class property ?
QSMember m;
if ( member( obj, p, &m ) && m.type() != QSMember::Identifier )
return TRUE;
// // dynamic property
// return data( obj )->hasProperty( p );
return FALSE;
}
QSObject QSClass::get( const QSObject *objPtr, const QString &p ) const
{
QSMember mem;
if ( !member( objPtr, p, &mem ) || mem.type() == QSMember::Identifier )
return createUndefined();
return fetchValue( objPtr, mem );
}
void QSClass::put( QSObject *objPtr, const QString &p,
const QSObject &v ) const
{
QSMember mem;
if ( !member( objPtr, p, &mem ) && mem.type() != QSMember::Identifier ) {
qWarning( "QSClass::put: refused write of %s", p.ascii() );
return;
}
mem.setName( p );
write( objPtr, mem, v );
}
QSObject QSClass::construct( const QSList & /* args */ ) const
{
return createUndefined();
}
QSObject QSClass::cast( const QSList &args ) const
{
return args.size() > 0 ? args[0] : createUndefined() ;
}
/*! Returns the map of members of \a obj or class members if \a obj
is 0.
The default implementation will list all members pre-defined
via the addMember() function or one of its specializations. Class
inherting from QSClass can reimplement this function to also give
information about custom properties.
*/
QSMemberMap QSClass::members( const QSObject *obj ) const
{
Q_ASSERT( mmap );
if ( obj )
return *mmap;
QSMemberMap m;
QSMemberMap::const_iterator it = mmap->begin();
for ( ; it != mmap->end(); ++it )
if ( (*it).isStatic() )
m.insert( it.key(), it.data() );
return m;
}
/*!
Convenience function to throw an error of type \a a with the user
visible message \a msg.
*/
void QSClass::throwError( ErrorType e, const QString &msg ) const
{
(void)env()->throwError( e, msg, -1 );
}
QSObject QSClass::createString( const QString &s ) const
{
return en->createString( s );
}
QSObject QSClass::createNumber( double d ) const
{
return en->createNumber( d );
}
QSObject QSClass::createBoolean( bool b ) const
{
return en->createBoolean( b );
}
QSObject QSClass::createUndefined() const
{
return en->createUndefined();
}
QSObject QSClass::createNull() const
{
return en->createNull();
}
bool QSUndefinedClass::toBoolean( const QSObject * ) const
{
return FALSE;
}
double QSUndefinedClass::toNumber( const QSObject * ) const
{
return NaN;
}
QString QSUndefinedClass::toString( const QSObject * ) const
{
return QString::fromLatin1("undefined");
}
QSObject QSUndefinedClass::toPrimitive( const QSObject *obj,
const QSClass * ) const
{
return *obj;
}
QSEqualsResult QSUndefinedClass::isEqual( const QSObject &a, const QSObject &b ) const
{
Q_ASSERT( a.isA( this ) );
if ( b.isUndefined() || b.isNull() )
return EqualsIsEqual;
else
return EqualsUndefined;
}
bool QSNullClass::toBoolean( const QSObject * ) const
{
return FALSE;
}
double QSNullClass::toNumber( const QSObject * ) const
{
return 0.0;
}
QString QSNullClass::toString( const QSObject * ) const
{
return QString::fromLatin1("null");
}
QSObject QSNullClass::toPrimitive( const QSObject *obj,
const QSClass * ) const
{
return *obj;
}
QSEqualsResult QSNullClass::isEqual( const QSObject &a, const QSObject &b ) const
{
Q_ASSERT( a.isA( this ) );
if( b.isNull() || b.isUndefined() )
return EqualsIsEqual;
return EqualsUndefined;
}
bool QSCharacterClass::toBoolean( const QSObject *obj ) const
{
return !obj->sVal()[0].isNull();
}
double QSCharacterClass::toNumber( const QSObject *obj ) const
{
return QSString::toDouble( obj->sVal() );
}
QString QSCharacterClass::toString( const QSObject *obj ) const
{
return obj->sVal();
}
void QSSharedClass::ref( QSObject * o ) const
{
#ifndef QS_LEAK
o->shVal()->ref();
#endif
}
void QSSharedClass::deref( QSObject * o ) const
{
#ifndef QS_LEAK
o->shVal()->deref();
if( o->shVal()->count==0 ) {
env()->removeShared( o->shVal() );
delete o->shVal();
o->setVal( (QSShared*)0 ); // for debugging purposes only
}
#endif
}
QSClassClass::QSClassClass( QSClass *b, int a, const QString &n )
: QSSharedClass( b, a ), cname( n ), defaultCtor( FALSE ), bodyNode( 0 ), clDefNode(0)
{
memberInit = new QSNodeList();
staticInit = new QSNodeList();
}
QSClassClass::~QSClassClass()
{
// If shut down, we cannot allow other classes to be deleted as this will
// mess up the iterators calling finalize, clear and delete in QSEnv::clear().
if (env()->isShuttingDown()) {
if (bodyNode->scopeDefinition())
bodyNode->scopeDefinition()->setFunctionBodyNode(0);
bodyNode->setScopeDefinition(0);
}
clDefNode->setClassDefinition(0);
if (clDefNode->deref()) {
delete clDefNode;
bodyNode = 0;
clDefNode = 0;
}
delete memberInit;
delete staticInit;
}
bool QSClassClass::toBoolean( const QSObject * ) const
{
return TRUE;
}
double QSClassClass::toNumber( const QSObject * ) const
{
return NaN;
}
QString QSClassClass::toString( const QSObject * ) const
{
return QString::fromLatin1("[class ") + cname + QString::fromLatin1("]");
}
QSInstanceData* QSClassClass::data( QSObject *obj )
{
return (QSInstanceData*)obj->shVal();
}
const QSInstanceData* QSClassClass::data( const QSObject *obj )
{
return (const QSInstanceData*)obj->shVal();
}
/*!
\reimp
Construct an instance of the class described by this object.
*/
QSObject QSClassClass::construct( const QSList &args ) const
{
/* Look for non QSClassClass in parent chain. Can only be object class. If anything
else, it must be a QSAbstractBaseClass, which is an error at this point. */
QSClass *baseChain = base();
while (baseChain && baseChain->asClass())
baseChain = baseChain->base();
if (baseChain && baseChain->name() == QString::fromLatin1("AbstractBase")) {
return env()->throwError(QString(QString::fromLatin1("class '%1' is %2derived from undefined class '%3'"))
.arg(cname)
.arg(baseChain == base()
? QString::fromLatin1("")
: QString::fromLatin1("indirectly "))
.arg(baseChain->identifier()));
}
// Initialize all entries to undefined
QSInstanceData *data = new QSInstanceData( numVariables(),
createUndefined() );
for( int i=0; i < numVariables(); i++ )
data->setValue( i, createUndefined() );
QSObject inst = env()->createShared( this, data );
// Set up scope
ScopeChain chain = env()->scope();
ScopeChain::Iterator sit = chain.begin();
while( sit!=chain.end() ) {
if( (*sit).objectType()==enclosingClass() ) {
break;
}
sit = chain.remove( sit );
}
// Fill up scope chain.
env()->pushScopeBlock();
while( chain.size()>0 ) {
env()->pushScope( chain.back() );
chain.pop_back();
}
env()->pushScope( inst );
initVariables( data );
// Clean up scope
env()->popScopeBlock();
if ( hasDefaultConstructor() && !env()->isExceptionMode() ) {
QSObject ctor = get( &inst, cname );
Q_ASSERT( ctor.isExecutable() );
ctor.invoke( QSMember(), args );
// ### do something with the return value/type ?
}
return inst;
}
QSEqualsResult QSClassClass::isEqual( const QSObject &a, const QSObject &b ) const
{
if( b.objectType() == this ) {
return ( QSEqualsResult ) ( b.shVal() == a.shVal() );
}
return EqualsNotEqual;
}
void QSClassClass::addMemberInitializer( QSNode * node )
{
memberInit->append( node );
}
void QSClassClass::addStaticInitializer( QSNode * node )
{
staticInit->append( node );
}
void QSClassClass::setClassBodyNode( QSFunctionBodyNode * node )
{
bodyNode = node;
}
/*!
Execute statements contained in this class' block.
*/
void QSClassClass::executeBlock( QSEnv *env )
{
// Set up scope
ScopeChain chain = env->scope();
ScopeChain::Iterator sit = chain.begin();
while( sit!=chain.end() ) {
if( (*sit).objectType()==enclosingClass() ) {
break;
}
sit = chain.remove( sit );
}
// Fill up scope chain.
env->pushScopeBlock();
while( chain.size()>0 ) {
env->pushScope( chain.back() );
chain.pop_back();
}
// Push the type object...
env->pushScope( env->globalObject().get(cname) );
// Call initializers
QPtrListIterator<QSNode> it( *staticInit );
for ( uint j = 0; j<staticInit->count(); j++ ) {
QSNode *init = it();
if ( init ) {
setStaticMember( j, init->rhs( env ) );
// abort if init code caused an error
if ( env->isExceptionMode() )
break;
}
}
if( bodyNode )
bodyNode->execute( env );
// Clean up scope
env->popScopeBlock();
}
/*!
\internal
Runs the initializers on the variables declared in this class. This function
assumes that scopes are set up correctly and can only be called from
within the QSClassClass::construct function.
*/
int QSClassClass::initVariables( QSInstanceData * data ) const
{
int offset = 0;
QSClassClass *cl = base() ? base()->asClass() : 0;
if( cl )
offset = cl->initVariables( data );
// Call initializers
QPtrListIterator<QSNode> it( *memberInit );
for ( uint j = 0; j<memberInit->count(); j++ ) {
QSNode *init = it();
if ( init ) {
data->setValue( offset + j, init->rhs( env() ) );
// abort if init code caused an error
if ( env()->isExceptionMode() )
break;
}
}
return offset + memberInit->count();
}
/*!
\reimp
*/
void QSWritableClass::mark( QSObject * /*o*/ ) const
{
}
bool QSWritableClass::member( const QSObject *o, const QString &n,
QSMember *m ) const
{
// qDebug( "QSWritableClass::member() class = %s, name = %s", name().latin1(), n.latin1() );
Q_ASSERT( /* o &&*/ !n.isEmpty() );
Q_ASSERT( m );
if( !o || !o->isDefined() ) {
return QSClass::member( o, n, m );
}
if( !o->shVal() ) {
return QSClass::member( 0, n, m );
}
// The error here is that the object is a dummy!!!
const QSWritable *w = (QSWritable*) o->shVal(); //data( o );
if ( !w->hasProperty( n ) ) {
if ( QSClass::member( o, n, m ) )
return TRUE;
// property doesn't exit, yet. We'll offer to create a new one
m->setType( QSMember::Identifier );
m->setName( n );
m->setOwner( this );
return FALSE;
}
m->setType( QSMember::Object );
m->obj = &w->reference( n )->object;
m->setName( n );
m->setOwner( this );
return TRUE;
}
QSObject QSWritableClass::fetchValue( const QSObject *objPtr,
const QSMember &mem ) const
{
// qDebug( "QSWritableClass::fetchValue() -> mem.type = %s", mem.typeName().latin1() );
if( mem.type()==QSMember::Object ) {
return *mem.obj;
}
return QSClass::fetchValue( objPtr, mem );
}
void QSWritableClass::write( QSObject *objPtr, const QSMember &mem,
const QSObject &val ) const
{
// qDebug( "QSWritableClass::write() -> mem.type = %s", mem.typeName().latin1() );
if( mem.type()==QSMember::Object ) {
*mem.obj = val;
} else if( mem.type()==QSMember::Identifier ) {
// qDebug( "Writing to QSMember::Identifier: name = %s", mem.str.latin1() );
data( objPtr )->setProperty( mem.name(), QSProperty( val ) );
} else {
QSClass::write( objPtr, mem, val );
}
}
bool QSWritableClass::deleteProperty( QSObject *obj, const QSMember &mem ) const
{
if ( mem.type()==QSMember::Object ) {
properties( obj )->remove( mem.name() );
return TRUE;
}
return FALSE;
}
QSObject QSWritableClass::invoke( QSObject * objPtr, const QSMember &mem ) const
{
if( mem.type()==QSMember::Object ) {
Q_ASSERT( mem.obj->isValid() );
return objPtr->invoke( mem, *env()->arguments() );
}
return QSClass::invoke( objPtr, mem );
}
QSWritable *QSWritableClass::data( QSObject *obj )
{
return (QSWritable*)obj->shVal();
}
const QSWritable *QSWritableClass::data( const QSObject *obj )
{
return (const QSWritable*)obj->shVal();
}
/*!
Create an empty, writable object of this class.
*/
QSObject QSWritableClass::createWritable() const
{
return QSObject( this, new QSWritable() );
}
QSPropertyMap *QSWritableClass::properties( const QSObject *obj ) const
{
return data( obj )->properties();
}
/*!
\reimp
Returns the pre-defined members plus dynamic properties of \a obj.
*/
QSMemberMap QSWritableClass::members( const QSObject *obj ) const
{
QSMemberMap map = QSClass::members( obj );
if ( obj ) {
QSPropertyMap *pmap = properties( obj );
if ( pmap ) {
QSPropertyMap::ConstIterator it = pmap->begin();
while ( it != pmap->end() ) {
QSMember mem( QSMember::Object, AttributeEnumerable );
mem.setName( it.key() );
mem.setExecutable( it.data().object.isExecutable() );
map.insert( it.key(), mem );
++it;
}
}
}
return map;
}
QSEqualsResult QSWritableClass::isEqual( const QSObject &a, const QSObject &b ) const
{
if( b.objectType() == this ) {
return ( QSEqualsResult ) ( b.shVal() == a.shVal() );
}
return EqualsNotEqual;
}
QSFunctionScopeClass::QSFunctionScopeClass( QSClass *b, QSFuncDeclNode * func )
: QSWritableClass( b ), ident(func->identifier()), numArgs( 0 ), body_node(0)
{
}
QString QSFunctionScopeClass::identifier() const
{
return ident.isNull() ? QString(QString::fromLatin1("[anonymous]")) : ident;
}
void QSFunctionScopeClass::clear()
{
if (body_node)
body_node->setScopeDefinition(0);
body_node = 0;
QSWritableClass::clear();
}
QSObject QSFunctionScopeClass::construct( const QSList &args ) const
{
// qDebug( "Creating functions scope for: " + identifier() + ", %d", numVariables() );
QSInstanceData *dat = new QSInstanceData( numVariables(),
createUndefined() );
QSObject scope = env()->createShared( this, dat );
// fill slots for passed arguments
QSListIterator it = args.begin();
int i = 0;
while ( it != args.end() && i < numArguments() ) {
dat->setValue( i, *it );
it++;
i++;
}
// intialize remaining ones with "undefined"
while ( i < numArguments() )
dat->setValue( i++, createUndefined() );
QSArray argObj( env() );
it = args.begin();
for ( i = 0; it != args.end(); ++i, ++it )
argObj.put( QString::number( i ), *it );
scope.put( QString::fromLatin1("arguments"), argObj );
return scope;
}
QSObject QSEvalScopeClass::construct( const QSList & ) const
{
return env()->createShared( this,
new QSInstanceData( numVariables(),
createUndefined() ) );
}
void QSBlockScopeClass::activateScope() const
{
QSObject scope( this );
scope.setVal( env()->currentScope().shVal() );
ref( &scope );
env()->pushScope( scope );
}
void QSBlockScopeClass::deactivateScope() const
{
env()->popScope();
}
QSMemberMap QSBlockScopeClass::members( const QSObject *obj ) const
{
QSMemberMap newMap( *definedMembers() );
QSMemberMap encMap = enclosingClass()->members( obj );
QSMemberMap::ConstIterator it = encMap.begin();
while( it!=encMap.end() ) {
newMap[ it.key() ] = it.data();
it++;
}
return newMap;
}
class QSTypeClassShared : public QSShared
{
public:
QSTypeClassShared(QSClass *cl)
: classValue(cl)
{
}
~QSTypeClassShared()
{
// Delete the class when it is cleared.
if (!classValue->env()->isShuttingDown()) {
classValue->env()->unregisterClass(classValue);
classValue->clear();
delete classValue;
}
}
QSClass *classValue;
};
QSShared *QSTypeClass::createTypeShared(QSClass *cl) const
{
return new QSTypeClassShared(cl);
}
QSObject QSTypeClass::createType(QSClass *cl) const
{
return QSObject(this, new QSTypeClassShared(cl));
}
QSClass *QSTypeClass::classValue(const QSObject *obj)
{
Q_ASSERT(obj->objectType()->inherits(obj->objectType()->env()->typeClass()));
return ((QSTypeClassShared *)obj->shVal())->classValue;
}
bool QSTypeClass::member( const QSObject *o, const QString &n,
QSMember *m ) const
{
if( !o )
return FALSE;
Q_ASSERT( o->isA( this ) );
QSClass *tcl = classValue(o);
return tcl->member( 0, n, m );
}
QSMemberMap QSTypeClass::members( const QSObject *obj ) const
{
Q_ASSERT( obj->isA( this ) );
if ( ( ( const QSClass * ) classValue(obj) ) == this )
return QSClass::members( obj );
else
return classValue(obj)->members( 0 );
}
QSMemberMap QSTypeClass::allMembers( const QSObject *obj ) const
{
Q_ASSERT( obj->isA( this ) );
if ( ( ( const QSClass * ) classValue(obj) ) == this )
return QSClass::members( obj );
else
return *( classValue(obj)->definedMembers() );
}
QSObject QSTypeClass::fetchValue( const QSObject *o,
const QSMember &mem ) const
{
Q_ASSERT( o->isA( this ) );
if ( !mem.hasAttribute( AttributeStatic ) ) {
throwError( ReferenceError, QString::fromLatin1("Cannot access a non-static member "
"without an object reference") );
return createUndefined();
}
QSClass *tcl = classValue(o);
return tcl->fetchValue( o, mem );
}
QSObject QSTypeClass::invoke( QSObject *o, const QSMember &mem ) const
{
Q_ASSERT( o->objectType()==this );
// we are not interested in static functions
if ( mem.isStatic() )
return QSClass::invoke( o, mem );
else if( mem.type()==QSMember::Variable ) // Indirect casting.
return classValue(o)->cast( *env()->arguments() );
throwError( ReferenceError, QString::fromLatin1("Cannot invoke a non-static function "
"without an object reference") );
return createUndefined();
}
void QSTypeClass::write( QSObject *objPtr, const QSMember &mem,
const QSObject &val ) const
{
Q_ASSERT( mem.isWritable() );
// Q_ASSERT( mem.type()==QSMember::Variable );
if ( !mem.hasAttribute( AttributeStatic ) ) {
throwError( ReferenceError, QString::fromLatin1("Cannot access a non-static member "
"without an object reference") );
return;
}
QSClass * cl = classValue(objPtr);
if( mem.type()==QSMember::Variable ) {
cl->setStaticMember( mem.idx, val );
}
else {
throwError( ReferenceError, QString::fromLatin1("Trying to write to a nonvariable") );
return;
}
}
QSEqualsResult QSTypeClass::isEqual( const QSObject &a, const QSObject &b ) const
{
if( b.objectType()==this ) {
return ( QSEqualsResult ) ( classValue(&a) == classValue(&b) );
}
return EqualsUndefined;
}
static void qs_dumpclass( const QSClass *cl )
{
printf( "class %s", cl->identifier().latin1() );
printf( " - %s\n", cl->isExecutable() ? "executable" : "not executable" );
printf( " - %s\n", cl->isFinal() ? "final" : "not final" );
QSMemberMap::Iterator it = cl->definedMembers()->begin();
for( ; it!=cl->definedMembers()->end(); it++ ) {
QSMember mem = *it;
QString line = QString(QString::fromLatin1(" ")) + mem;
printf( "%s\n", line.latin1() );
}
if( cl->enclosingClass() )
qs_dumpclass( cl->enclosingClass() );
if( cl->base() )
qs_dumpclass( cl->base() );
}
static void qs_dumptype( const QSList &args )
{
if ( args.size()>=1 &&
args[0].objectType()==args[0].objectType()->env()->typeClass() ) {
printf( "DUMP TYPE::\n" );
QSObject arg0 = args[0];
QSClass *cl = QSTypeClass::classValue(&arg0);
qs_dumpclass( cl );
}
printf( "\n" );
}
static void qs_dumpobject( const QSObject &obj )
{
const QSClass * cl = obj.objectType();
printf( "DUMP OBJECT:: %p\n", obj.shVal() );
printf( "class %s :: %s\n",
cl->name().latin1(),
cl->identifier().latin1() );
QSMemberMap::Iterator it = cl->definedMembers()->begin();
for( ; it!=cl->definedMembers()->end(); it++ ) {
QSMember mem = *it;
if( mem.isReadable() ) {
QSObject value = cl->fetchValue( &obj, mem );
if( mem.type()==QSMember::Variable )
printf( " %2d: %s = %s\n", mem.index(), mem.name().latin1(), value.toString().latin1() );
else
printf( " %s = %s\n", mem.name().latin1(), value.toString().latin1() );
}
}
}
QSDebugClass::QSDebugClass( QSClass *base )
: QSClass( base, AttributeAbstract )
{
addMember( QString::fromLatin1("dumpObject"),
QSMember( &dumpObject, AttributeNonWritable|AttributeStatic ) );
addMember( QString::fromLatin1("dumpScope"),
QSMember( &dumpScope, AttributeNonWritable|AttributeStatic ) );
addMember( QString::fromLatin1("dumpType"),
QSMember( &dumpType, AttributeNonWritable|AttributeStatic ) );
}
void QSDebugClass::dumpObject( QSEnv * env )
{
qs_dumpobject( ( env->numArgs() > 0 ? env->arg( 0 ) : env->createUndefined() ) );
}
void QSDebugClass::dumpScope( QSEnv * env )
{
ScopeChain chain = env->scope();
ScopeChain::ConstIterator it = chain.begin();
qDebug( "\n---------- DUMP SCOPE ----------" );
while( it!=chain.end() ) {
qs_dumpobject( *it );
if( (*it).objectType() == env->typeClass() ) {
QSList itList( *it );
qs_dumptype( itList );
}
it++;
}
qDebug( "---------- DUMP COMPLETE ----------" );
}
void QSDebugClass::dumpType( QSEnv * env )
{
qs_dumptype( *env->arguments() );
}
QSSystemClass::QSSystemClass( QSClass *base )
: QSClass( base, AttributeAbstract )
{
addMember( QString::fromLatin1("print"),
QSMember( &print, AttributeNonWritable | AttributeStatic ) );
addMember( QString::fromLatin1("println"),
QSMember( &println, AttributeNonWritable | AttributeStatic ) );
addMember( QString::fromLatin1("getenv"),
QSMember( &getenv, AttributeNonWritable | AttributeStatic ) );
addMember( QString::fromLatin1("setenv"),
QSMember( &setenv, AttributeNonWritable | AttributeStatic ) );
}
void QSSystemClass::println( QSEnv *env )
{
printf( "%s\n", env->arg( 0 ).toString().latin1() );
}
void QSSystemClass::print( QSEnv *env )
{
printf( "%s", env->arg( 0 ).toString().latin1() );
}
QSObject QSSystemClass::getenv( QSEnv *env )
{
return env->createString( QString::fromLatin1(::getenv( env->arg( 0 ).toString().latin1() )) );
}
void QSSystemClass::setenv( QSEnv *env )
{
#if defined(Q_OS_HPUX) || defined(Q_OS_IRIX) || defined(Q_OS_SOLARIS) || defined( Q_CC_BOR )
putenv( (char*)( env->arg( 0 ).toString() + "="
+ env->arg( 1 ).toString() ).latin1() ); // char* on Solaris
#elif defined(Q_OS_WIN32)
_putenv( QString::fromLatin1("%1=%2")
.arg(env->arg( 0 ).toString())
.arg(env->arg( 1 ).toString() ).latin1() );
#else
::setenv( (char *)env->arg( 0 ).toString().latin1(),
(char *)env->arg( 1 ).toString().latin1(), 1 );
#endif
}
/* Implementation of the QSAbstractBaseClass.
* Used primarly to support cross referencing of class between files, e.g.
* declaring a class in one file and deriving from it in another.
*/
void QSAbstractBaseClass::replace(QSClassClass *newBase)
{
QPtrList<QSClassClass> userClasses;
QPtrList<QSClass> allClasses = env()->classes();
// Build a list of the user classes, excluding this one.
QPtrListIterator<QSClass> it(allClasses);
QSClass *tmp;
while ((tmp = it()))
if (tmp->asClass() && tmp != newBase)
userClasses.append((QSClassClass*)tmp);
// Check if userclasses have this abstract class definition as parent and update
// member table if so.
QPtrListIterator<QSClassClass> userIt(userClasses);
QPtrList<QSClassClass> directChildren;
QSClassClass *userClass;
while ((userClass = userIt())) {
QSClass *baseClass = userClass->base();
// Directly derived, base pointer must be updated later
if (userClass->base() == this)
directChildren.append(userClass);
while (baseClass && baseClass != this)
baseClass = baseClass->base();
// update offsets in member table...
if (baseClass == this) {
userClass->setNumVariables(newBase->numVariables() + userClass->numVariables());
QSMemberMap *mems = userClass->definedMembers();
for (QSMemberMap::Iterator it = mems->begin(); it != mems->end(); ++it) {
QSMember &m = (*it);
if (m.type() == QSMember::Variable && !m.isStatic())
m.setIndex(m.index()+newBase->numVariables());
}
}
}
userIt = QPtrListIterator<QSClassClass>(directChildren);
while ((userClass = userIt()))
userClass->setBase(newBase);
// We no longer serve any purpose, so we disappear...
env()->unregisterClass(this);
clear();
delete this;
};
QSInstanceData::QSInstanceData( int count, const QSObject &def )
{
vals = new QSObject[count];
sz = count;
for( int i=0; i<count; i++ )
vals[i] = def;
}
void QSInstanceData::resize( int count, const QSObject &def )
{
QSObject *tmp = vals;
vals = new QSObject[count];
for( int i=0; i<sz; i++ ) {
vals[i] = tmp[i];
}
for( int j=sz; j<count; j++ )
vals[j] = def;
delete [] tmp;
sz = count;
}
/*!
Insure that this object has enough space for \a count objects.
If that is already the case the array won't be resized.
*/
void QSInstanceData::ensureSize( int count, const QSObject &def )
{
if ( count > sz )
resize( count, def );
}
/*!
Invalidates all the objects in this instance data so that
it can be destroyed at a later time without any problems without
further reference counting.
*/
void QSInstanceData::invalidate()
{
for( int i=0; i<sz; i++ ) {
vals[i].invalidate();
}
QSWritable::invalidate();
}
QString operator+( const QString &a, const QSMember &b )
{
QString s;
s.sprintf( "QSMember(%s.%s, %s, %x)",
b.owner() ? b.owner()->identifier().latin1() : "(no owner)",
b.name().latin1(),
b.typeName().latin1(),
b.attributes() );
return a + s;
}
bool operator==( const QSMember &a, const QSMember &b )
{
return a.type() == b.type() && a.owner() == b.owner() &&
!a.name().isEmpty() && a.name() == b.name();
}
| 26.810306 | 109 | 0.622215 | hackbinary |
b4408f5060b26eed1b6e0d09c85abd16a62a44ab | 7,845 | cpp | C++ | ctl/source/modes/mirroring/ModeSetState.cpp | TomatoYoung/beegfs | edf287940175ecded493183209719d2d90d45374 | [
"BSD-3-Clause"
] | null | null | null | ctl/source/modes/mirroring/ModeSetState.cpp | TomatoYoung/beegfs | edf287940175ecded493183209719d2d90d45374 | [
"BSD-3-Clause"
] | null | null | null | ctl/source/modes/mirroring/ModeSetState.cpp | TomatoYoung/beegfs | edf287940175ecded493183209719d2d90d45374 | [
"BSD-3-Clause"
] | null | null | null | #include "ModeSetState.h"
#include <common/net/message/nodes/SetTargetConsistencyStatesMsg.h>
#include <common/net/message/nodes/SetTargetConsistencyStatesRespMsg.h>
#include <common/toolkit/MessagingTk.h>
#include <common/toolkit/UiTk.h>
#include <program/Program.h>
#define MODESETSTATE_ARG_TARGETID "--targetid"
#define MODESETSTATE_ARG_NODEID "--nodeid"
#define MODESETSTATE_ARG_STATE "--state"
#define MODESETSTATE_ARG_STATE_GOOD "good"
#define MODESETSTATE_ARG_STATE_BAD "bad"
#define MODESETSTATE_ARG_FORCE "--force"
int ModeSetState::execute()
{
App* app = Program::getApp();
StringMap* cfg = app->getConfig()->getUnknownConfigArgs();
uint16_t cfgTargetID = 0;
TargetConsistencyState cfgState;
if (!ModeHelper::checkRootPrivileges())
return APPCODE_RUNTIME_ERROR;
nodeType = ModeHelper::nodeTypeFromCfg(cfg);
if (this->nodeType != NODETYPE_Meta && this->nodeType != NODETYPE_Storage)
{
std::cerr << "Invalid or missing node type." << std::endl;
return APPCODE_INVALID_CONFIG;
}
StringMapIter iter = cfg->find(MODESETSTATE_ARG_TARGETID);
if(iter != cfg->end() )
{
if (nodeType == NODETYPE_Meta)
{
std::cerr << "TargetIDs are only supported when setting state of storage targets. "
"For metadata servers, plase use the --nodeID parameter." << std::endl;
return APPCODE_INVALID_CONFIG;
}
bool isNumericRes = StringTk::isNumeric(iter->second);
if(!isNumericRes)
{
std::cerr << "Invalid targetID given (must be numeric): " << iter->second << std::endl;
return APPCODE_INVALID_CONFIG;
}
cfgTargetID = StringTk::strToUInt(iter->second);
cfg->erase(iter);
}
iter = cfg->find(MODESETSTATE_ARG_NODEID);
if (iter != cfg->end())
{
if (nodeType == NODETYPE_Storage)
{
std::cerr << "NodeIDs are only supported when setting state of metadata nodes. "
"For storage targets, please use the --targetID parameter." << std::endl;
return APPCODE_INVALID_CONFIG;
}
bool isNumericRes = StringTk::isNumeric(iter->second);
if (!isNumericRes)
{
std::cerr << "Invalid nodeID given (must be numeric): " << iter->second << std::endl;
return APPCODE_INVALID_CONFIG;
}
cfgTargetID = StringTk::strToUInt(iter->second);
cfg->erase(iter);
}
iter = cfg->find(MODESETSTATE_ARG_STATE);
if (iter != cfg->end())
{
if (iter->second == MODESETSTATE_ARG_STATE_GOOD)
{
cfg->erase(iter); // erase the "--state"
iter = cfg->find(MODESETSTATE_ARG_FORCE);
if (iter == cfg->end())
{
std::cerr << "If state should be set to \"good\", --force must be given." << std::endl;
return APPCODE_INVALID_CONFIG;
}
cfg->erase(iter); // erase the "--force"
cfgState = TargetConsistencyState_GOOD;
}
else if (iter->second == MODESETSTATE_ARG_STATE_BAD)
{
cfgState = TargetConsistencyState_BAD;
cfg->erase(iter); // erase the "--state"
}
else
{
std::cerr << "Invalid state given (must be \"good\" or \"bad\"): "
<< iter->second << std::endl;
return APPCODE_INVALID_CONFIG;
}
}
else
{
std::cerr << "State must be specified." << std::endl;
return APPCODE_INVALID_CONFIG;
}
if (ModeHelper::checkInvalidArgs(cfg))
return APPCODE_INVALID_CONFIG;
if (!uitk::userYNQuestion("WARNING!\n\nThis command is very dangerous and can cause serious data "
"loss.\n"
"It should not be used under normal circumstances. It is absolutely recommended to contact "
"support before proceeding."))
return APPCODE_INVALID_CONFIG;
return doSet(cfgTargetID, cfgState);
}
void ModeSetState::printHelp()
{
std::cout << "MODE ARGUMENTS:" << std::endl;
std::cout << " Mandatory:" << std::endl;
std::cout << " --nodetype=<nodetype> The node type (metadata, storage)." << std::endl;
std::cout << " --targetid=<targetID> The ID of the target whose state should be" << std::endl;
std::cout << " set." << std::endl;
std::cout << " (only for nodetype=storage)" << std::endl;
std::cout << " --nodeid=<nodeID> The ID of the node whose state should be set." << std::endl;
std::cout << " (only for nodetype=metadata)" << std::endl;
std::cout << " --state=<state> The state to be set (\"good\" or \"bad\")." << std::endl;
std::cout << std::endl;
std::cout << "USAGE:" << std::endl;
std::cout << " This mode can be used to forcefully set the state of a target or node. This is" << std::endl;
std::cout << " useful to manually set a target or node to the state \"bad\", or to resolve a" << std::endl;
std::cout << " situation in which both buddies in a buddy mirror group are in the state" << std::endl;
std::cout << " \"needs-resync\"." << std::endl;
std::cout << std::endl;
std::cout << " Example: Set a metadata node to \"bad\"" << std::endl;
std::cout << " $ beegfs-ctl --setstate --nodetype=metadata --nodeid=10 --state=bad" << std::endl;
}
int ModeSetState::doSet(uint16_t targetID, TargetConsistencyState state)
{
App* app = Program::getApp();
// Send message to mgmtd
auto nodes = app->getMgmtNodes();
NodeHandle node = nodes->referenceFirstNode();
UInt16List targetIDs(1, targetID);
UInt8List states(1, (uint8_t)state);
SetTargetConsistencyStatesMsg msg(nodeType, &targetIDs, &states, false);
{
const auto respMsgRaw = MessagingTk::requestResponse(*node, msg,
NETMSGTYPE_SetTargetConsistencyStatesResp);
if (!respMsgRaw)
{
std::cerr << "Communication with node not successful." << std::endl;
return APPCODE_RUNTIME_ERROR;
}
SetTargetConsistencyStatesRespMsg* respMsgCast =
reinterpret_cast<SetTargetConsistencyStatesRespMsg*>(respMsgRaw.get());
if (respMsgCast->getResult() != FhgfsOpsErr_SUCCESS)
{
std::cerr << "Management host did not accept state change. Error: "
<< respMsgCast->getResult() << std::endl;
return APPCODE_RUNTIME_ERROR;
}
}
// Send message to node
if (nodeType == NODETYPE_Storage)
{
TargetMapper* targetMapper = app->getTargetMapper();
FhgfsOpsErr err;
nodes = app->getStorageNodes();
node = nodes->referenceNodeByTargetID(targetID, targetMapper, &err);
if (!node)
{
std::cerr << "Unable to resolve node for target ID " << targetID <<
". Error: " << err << std::endl;
return APPCODE_RUNTIME_ERROR;
}
}
else
{
nodes = app->getMetaNodes();
node = nodes->referenceNode(NumNodeID(targetID));
if (!node)
{
std::cerr << "Unable to resolve node for node ID " << targetID << std::endl;
return APPCODE_RUNTIME_ERROR;
}
}
{
const auto respMsgRaw = MessagingTk::requestResponse(*node, msg,
NETMSGTYPE_SetTargetConsistencyStatesResp);
if (!respMsgRaw)
{
std::cerr << "Communication with node not successful." << std::endl;
return APPCODE_RUNTIME_ERROR;
}
auto respMsgCast = reinterpret_cast<SetTargetConsistencyStatesRespMsg*>(respMsgRaw.get());
if (respMsgCast->getResult() != FhgfsOpsErr_SUCCESS)
{
std::cerr << "Node did not accept state change. Error: "
<< respMsgCast->getResult() << std::endl;
return APPCODE_RUNTIME_ERROR;
}
}
std::cout << "Successfully set state." << std::endl;
return APPCODE_NO_ERROR;
}
| 33.814655 | 111 | 0.613384 | TomatoYoung |
b4430917bc5a21408a8e649f6fa76d2e8354ea28 | 39 | cpp | C++ | src/task_base_pro/task_group.cpp | maxcong001/task_base_pro | 2f309ea790c615389ecce3882cea7cca4aab93e3 | [
"MIT"
] | 1 | 2018-03-06T08:37:46.000Z | 2018-03-06T08:37:46.000Z | src/task_base_pro/task_group.cpp | maxcong001/task_base_pro | 2f309ea790c615389ecce3882cea7cca4aab93e3 | [
"MIT"
] | null | null | null | src/task_base_pro/task_group.cpp | maxcong001/task_base_pro | 2f309ea790c615389ecce3882cea7cca4aab93e3 | [
"MIT"
] | null | null | null | #include "task_base_pro/task_group.hpp" | 39 | 39 | 0.846154 | maxcong001 |
b444253c17b560fbd15ac4a5f17eaaf13fb41b28 | 9,030 | cpp | C++ | src/prod/src/Reliability/LoadBalancing/Metric.cpp | vishnuk007/service-fabric | d0afdea185ae932cc3c9eacf179692e6fddbc630 | [
"MIT"
] | 2,542 | 2018-03-14T21:56:12.000Z | 2019-05-06T01:18:20.000Z | src/prod/src/Reliability/LoadBalancing/Metric.cpp | vishnuk007/service-fabric | d0afdea185ae932cc3c9eacf179692e6fddbc630 | [
"MIT"
] | 994 | 2019-05-07T02:39:30.000Z | 2022-03-31T13:23:04.000Z | src/prod/src/Reliability/LoadBalancing/Metric.cpp | vishnuk007/service-fabric | d0afdea185ae932cc3c9eacf179692e6fddbc630 | [
"MIT"
] | 300 | 2018-03-14T21:57:17.000Z | 2019-05-06T20:07:00.000Z | // ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
#include "stdafx.h"
#include "Metric.h"
using namespace std;
using namespace Common;
using namespace Reliability::LoadBalancingComponent;
Metric::Metric(
wstring && name,
double weight,
double balancingThreshold,
DynamicBitSet && blockList,
uint activityThreshold,
int64 clusterTotalCapacity,
int64 clusterBufferedCapacity,
int64 clusterLoad,
bool isDefrag,
int32 defragEmptyNodeCount,
size_t defragEmptyNodeLoadThreshold,
int64 reservationLoad,
DefragDistributionType defragEmptyNodesDistribution,
double placementHeuristicIncomingLoadFactor,
double placementHeuristicEmptySpacePercent,
bool defragmentationScopedAlgorithmEnabled,
PlacementStrategy placementStrategy,
double defragmentationEmptyNodeWeight,
double defragmentationNonEmptyNodeWeight,
bool balancingByPercentage)
: name_(move(name)),
weight_(weight),
balancingThreshold_(balancingThreshold),
blockList_(move(blockList)),
isBalanced_(false),
activityThreshold_(activityThreshold),
clusterTotalCapacity_(clusterTotalCapacity),
clusterBufferedCapacity_(clusterBufferedCapacity),
clusterLoad_(clusterLoad),
isDefrag_(isDefrag),
defragEmptyNodeCount_(defragEmptyNodeCount),
defragEmptyNodeLoadThreshold_(defragEmptyNodeLoadThreshold),
reservationLoad_(reservationLoad),
defragEmptyNodesDistribution_(defragEmptyNodesDistribution),
placementHeuristicIncomingLoadFactor_(placementHeuristicIncomingLoadFactor),
placementHeuristicEmptySpacePercent_(placementHeuristicEmptySpacePercent),
defragmentationScopedAlgorithmEnabled_(defragmentationScopedAlgorithmEnabled),
placementStrategy_(placementStrategy),
defragmentationEmptyNodeWeight_(defragmentationEmptyNodeWeight),
defragmentationNonEmptyNodeWeight_(defragmentationNonEmptyNodeWeight),
balancingByPercentage_(balancingByPercentage)
{
// 1.0 means do balancing for any diff, 0.0 means infinity, e.g. never trigger balancing
ASSERT_IFNOT(balancingThreshold >= 1.0 || balancingThreshold == 0.0,
"balancingThreshold should >= 1 or == 0, current value is {0}", balancingThreshold);
}
Metric::Metric(Metric const & other)
: name_(other.name_),
weight_(other.weight_),
balancingThreshold_(other.balancingThreshold_),
blockList_(other.blockList_),
isBalanced_(other.isBalanced_),
activityThreshold_(other.activityThreshold_),
clusterTotalCapacity_(other.clusterTotalCapacity_),
clusterBufferedCapacity_(other.clusterBufferedCapacity_),
clusterLoad_(other.clusterLoad_),
isDefrag_(other.isDefrag_),
defragEmptyNodeCount_(other.defragEmptyNodeCount_),
defragEmptyNodeLoadThreshold_(other.defragEmptyNodeLoadThreshold_),
reservationLoad_(other.reservationLoad_),
defragEmptyNodesDistribution_(other.defragEmptyNodesDistribution_),
placementHeuristicIncomingLoadFactor_(other.placementHeuristicIncomingLoadFactor_),
placementHeuristicEmptySpacePercent_(other.placementHeuristicEmptySpacePercent_),
defragmentationScopedAlgorithmEnabled_(other.defragmentationScopedAlgorithmEnabled_),
placementStrategy_(other.placementStrategy_),
defragmentationEmptyNodeWeight_(other.defragmentationEmptyNodeWeight_),
defragmentationNonEmptyNodeWeight_(other.defragmentationNonEmptyNodeWeight_),
balancingByPercentage_(other.balancingByPercentage_),
indexInGlobalDomain_(other.indexInGlobalDomain_),
indexInLocalDomain_(other.indexInLocalDomain_),
indexInTotalDomain_(other.indexInTotalDomain_)
{
}
Metric::Metric(Metric && other)
: name_(move(other.name_)),
weight_(other.weight_),
balancingThreshold_(other.balancingThreshold_),
blockList_(move(other.blockList_)),
isBalanced_(other.isBalanced_),
activityThreshold_(other.activityThreshold_),
clusterTotalCapacity_(other.clusterTotalCapacity_),
clusterBufferedCapacity_(other.clusterBufferedCapacity_),
clusterLoad_(other.clusterLoad_),
isDefrag_(other.isDefrag_),
defragEmptyNodeCount_(other.defragEmptyNodeCount_),
defragEmptyNodeLoadThreshold_(other.defragEmptyNodeLoadThreshold_),
reservationLoad_(other.reservationLoad_),
defragEmptyNodesDistribution_(other.defragEmptyNodesDistribution_),
placementHeuristicIncomingLoadFactor_(other.placementHeuristicIncomingLoadFactor_),
placementHeuristicEmptySpacePercent_(other.placementHeuristicEmptySpacePercent_),
defragmentationScopedAlgorithmEnabled_(other.defragmentationScopedAlgorithmEnabled_),
placementStrategy_(other.placementStrategy_),
defragmentationEmptyNodeWeight_(other.defragmentationEmptyNodeWeight_),
defragmentationNonEmptyNodeWeight_(other.defragmentationNonEmptyNodeWeight_),
balancingByPercentage_(other.balancingByPercentage_),
indexInGlobalDomain_(other.indexInGlobalDomain_),
indexInLocalDomain_(other.indexInLocalDomain_),
indexInTotalDomain_(other.indexInTotalDomain_)
{
}
Metric & Metric::operator = (Metric && other)
{
if (this != &other)
{
name_ = move(other.name_);
weight_ = other.weight_;
balancingThreshold_ = other.balancingThreshold_;
blockList_ = move(other.blockList_);
isBalanced_ = other.isBalanced_;
activityThreshold_ = other.activityThreshold_;
clusterTotalCapacity_ = other.clusterTotalCapacity_;
clusterBufferedCapacity_ = other.clusterBufferedCapacity_;
clusterLoad_ = other.clusterLoad_;
isDefrag_ = other.isDefrag_;
defragEmptyNodeCount_ = other.defragEmptyNodeCount_;
defragEmptyNodeLoadThreshold_ = other.defragEmptyNodeLoadThreshold_;
reservationLoad_ = other.reservationLoad_;
defragEmptyNodesDistribution_ = other.defragEmptyNodesDistribution_;
placementHeuristicIncomingLoadFactor_ = other.placementHeuristicIncomingLoadFactor_;
placementHeuristicEmptySpacePercent_ = other.placementHeuristicEmptySpacePercent_;
defragmentationScopedAlgorithmEnabled_ = other.defragmentationScopedAlgorithmEnabled_;
placementStrategy_ = other.placementStrategy_;
defragmentationEmptyNodeWeight_ = other.defragmentationEmptyNodeWeight_;
defragmentationNonEmptyNodeWeight_ = other.defragmentationNonEmptyNodeWeight_;
balancingByPercentage_ = other.balancingByPercentage_;
indexInGlobalDomain_ = other.indexInGlobalDomain_;
indexInLocalDomain_ = other.indexInLocalDomain_;
indexInTotalDomain_ = other.indexInTotalDomain_;
}
return *this;
}
bool Metric::get_ShouldCalculateBeneficialNodesForPlacement() const
{
return isDefrag_ &&
(
placementHeuristicIncomingLoadFactor_ != 0 ||
placementHeuristicEmptySpacePercent_ != 0 ||
defragmentationScopedAlgorithmEnabled_
);
}
void Metric::WriteTo(TextWriter& writer, FormatOptions const&) const
{
writer.Write("{0}/{1}/{2}/{3}/{4}/{5}/{6}/{7}/{8}/{9}",
name_, weight_, balancingThreshold_, isBalanced_, blockList_,
activityThreshold_, clusterTotalCapacity_, clusterBufferedCapacity_,
clusterLoad_, balancingByPercentage_);
if (isDefrag_)
{
writer.Write("/{0}/{1}/{2}/{3}/{4}/{5}/{6}/{7}/{8}/{9}/{10}",
isDefrag_, defragEmptyNodeLoadThreshold_, reservationLoad_, defragEmptyNodeCount_,
defragEmptyNodesDistribution_, placementHeuristicIncomingLoadFactor_,
placementHeuristicEmptySpacePercent_, defragmentationScopedAlgorithmEnabled_,
defragmentationEmptyNodeWeight_, placementStrategy_, defragmentationNonEmptyNodeWeight_);
}
}
void Reliability::LoadBalancingComponent::WriteToTextWriter(Common::TextWriter & writer, Metric::DefragDistributionType const & val)
{
switch (val)
{
case Metric::DefragDistributionType::SpreadAcrossFDs_UDs:
writer.Write("SpreadAcrossFDsAndUDs");
break;
case Metric::DefragDistributionType::NumberOfEmptyNodes:
writer.Write("NoDistribution");
break;
}
}
void Reliability::LoadBalancingComponent::WriteToTextWriter(Common::TextWriter & writer, Metric::PlacementStrategy const & val)
{
switch (val)
{
case Metric::PlacementStrategy::Balancing:
writer.Write("Balancing");
break;
case Metric::PlacementStrategy::ReservationAndBalance:
writer.Write("ReservationAndBalance");
break;
case Metric::PlacementStrategy::Reservation:
writer.Write("Reservation");
break;
case Metric::PlacementStrategy::ReservationAndPack:
writer.Write("ReservationAndPack");
break;
case Metric::PlacementStrategy::Defragmentation:
writer.Write("Defragmentation");
break;
}
}
| 42.796209 | 132 | 0.762348 | vishnuk007 |
b44632d846ffa4a399d02535ab412d6c2efb437e | 2,141 | hpp | C++ | CaWE/ModelEditor/SceneView3D.hpp | dns/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | 3 | 2020-04-11T13:00:31.000Z | 2020-12-07T03:19:10.000Z | CaWE/ModelEditor/SceneView3D.hpp | DNS/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | null | null | null | CaWE/ModelEditor/SceneView3D.hpp | DNS/Cafu | 77b34014cc7493d6015db7d674439fe8c23f6493 | [
"MIT"
] | 1 | 2020-04-11T13:00:04.000Z | 2020-04-11T13:00:04.000Z | /*
Cafu Engine, http://www.cafu.de/
Copyright (c) Carsten Fuchs and other contributors.
This project is licensed under the terms of the MIT license.
*/
#ifndef CAFU_MODELEDITOR_SCENE_VIEW_3D_HPP_INCLUDED
#define CAFU_MODELEDITOR_SCENE_VIEW_3D_HPP_INCLUDED
#include "../Generic3DWindow.hpp"
#include "Models/Model_cmdl.hpp"
#include "Renderer3D.hpp"
namespace MatSys { class RenderMaterialT; }
namespace ModelEditor
{
class ChildFrameT;
class SceneView3DT : public Generic3DWindowT
{
public:
SceneView3DT(ChildFrameT* Parent);
Vector3fT TraceCameraRay(const wxPoint& RefPtWin, AnimPoseT::TraceResultT& ModelTR) const;
private:
// Implement virtual methods of Generic3DViewT base class.
virtual Vector3fT GetRefPtWorld(const wxPoint& RefPtWin) const;
virtual void InfoCameraChanged();
virtual void InfoRightMouseClick(wxMouseEvent& ME);
/// Renders the skeleton of the model with the given joints and matrices.
void RenderSkeleton(const ArrayT<CafuModelT::JointT>& Joints, const ArrayT<MatrixT>& Matrices, bool IsSubModel) const;
/// Renders a single pass of the scene.
void RenderPass() const;
ChildFrameT* m_Parent;
Renderer3DT m_Renderer; ///< Performs the 3D rendering in our window.
unsigned long m_TimeOfLastPaint; ///< The time at which the OnPaint() event handler was last called.
ArrayT<bool> m_JointSelCache; ///< Stores for each joint whether it is currently selected, updated every frame.
// Event handlers.
void OnKeyDown (wxKeyEvent& KE);
void OnMouseLeftDown(wxMouseEvent& ME); ///< We also handle "double-click" events in this method (use ME.ButtonDClick() for distinction).
void OnMouseLeftUp (wxMouseEvent& ME);
void OnMouseMove (wxMouseEvent& ME);
void OnContextMenu (wxContextMenuEvent& CE);
void OnPaint (wxPaintEvent& PE);
void OnIdle (wxIdleEvent& IE);
DECLARE_EVENT_TABLE()
};
}
#endif
| 33.453125 | 153 | 0.670715 | dns |
b45133d8540bdf687d88fd16ceb45b083c6d9fde | 20,604 | cxx | C++ | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 252 | 2020-12-16T15:34:43.000Z | 2022-03-31T23:21:37.000Z | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 23 | 2020-12-20T18:02:54.000Z | 2022-03-28T16:58:32.000Z | ivp/ivp_compact_builder/geompack_drdec3.cxx | DannyParker0001/Kisak-Strike | 99ed85927336fe3aff2efd9b9382b2b32eb1d05d | [
"Unlicense"
] | 42 | 2020-12-19T04:32:33.000Z | 2022-03-30T06:00:28.000Z | /* drdec3.f -- translated by f2c (version 19990311).
*/
#include <ivp_physics.hxx>
#if !( (defined(__MWERKS__) && defined(__POWERPC__)) || defined(GEKKO) )
#include <malloc.h>
#endif
#include <ivp_betterdebugmanager.hxx>
#include <geompack.hxx>
int IVP_Geompack::i_sign(int a, int b) {
int x;
x = (a >= 0 ? a : - a);
return( b >= 0 ? x : -x);
}
double IVP_Geompack::d_sign(double a, double b) {
double x;
x = (a >= 0 ? a : - a);
return( b >= 0 ? x : -x);
}
int IVP_Geompack::increase_memory(void **mem_block, int *mem_size, int size_of_element) {
//// void *new_mem = p_realloc(*mem_block, (*mem_size) * 2 * size_of_element);
#ifndef GEKKO
void *new_mem = p_realloc(*mem_block, (*mem_size + 1024) * size_of_element);
#else
void *new_mem = p_malloc( (*mem_size + 1024) * size_of_element );
#endif
if ( !new_mem ) {
return(0);
}
#ifdef GEKKO
memcpy(new_mem, mem_block, *mem_size);
#endif
*mem_block = new_mem;
return(1);
}
void IVP_Geompack::decompose(struct geompack_parameters *params) {
// Local variables
int i;
int retry_counter;
// Initializing variables
this->size_intworkarray = 12; // orig: maxiw [5000]. Should be divisible by 3 & 4!;
this->size_doubleworkarray = 12; // orig: maxwk [5000]. Should be divisible by 3 & 4!;
this->size_vcl = params->nvc + 2; // number of vertices (NOT bytesize of array!)
this->size_polyhedronfirstfaceoffset = 2; // Leave this to "2" if there will never be more than one polyhedron to decompose. <orig. maxhf [200]>
this->size_polyhedronfaceindices = 1; // number of entries (NOT bytesize of array!) <orig: maxpf [2000]>
this->size_facearrays = params->nface + 2; // <orig. maxfp [800]>
this->size_facevertexarrays = params->facep[params->nface*3]+2; // <orig. maxfv>
this->size_ev = 200;
this->hashtable_maxsize = 307;
int * n_original_vertices_out = params->nvc_out;
int * nface_out = params->nface_out;
int * n_work_vertices_out = params->nvert_out;
int * npolh_out = params->npolh_out;
double ** vcl_out = params->vcl_out;
int ** facep_out = params->facep_out;
int ** fvl_out = params->fvl_out;
*n_original_vertices_out = 0;
*nface_out = 0;
*n_work_vertices_out = 0;
*npolh_out = 0;
// TOLIN - relative tolerance used to determine TOL
// TOL - relative tolerance MAX(TOLIN,100.0D0*EPS) where
// EPS is approximation to machine epsilon
// ANGACC - min acceptable dihedral angle in degrees produced by
// a cut face
// RDACC - minimum acceptable relative distance between a cut
// plane and vertices not on plane
this->angacc = params->angacc * IVP_PI / 180.0;
this->rdacc = params->rdacc;
// Initialize some basic values
this->initcb_(params->tolin);
// allocate necessary dynamic memory
this->g_hashtable = (int *) p_calloc(this->hashtable_maxsize , sizeof(int));
this->g_intworkarray = (int *) p_calloc(this->size_intworkarray , sizeof(int)); // [5000]
this->g_doubleworkarray = (double *)p_calloc(this->size_doubleworkarray , sizeof(double)); // [5000]
this->g_polyhedronfirstfaceoffset = (int *) p_calloc(this->size_polyhedronfirstfaceoffset, sizeof(int)); // [200]
this->g_polyhedronfaceindices = (int *) p_calloc(this->size_polyhedronfaceindices , 2*sizeof(int)); // [4000]
this->g_normals = (double *)p_calloc(this->size_facearrays , 3*sizeof(double)); // [2400]
this->g_facesdata = (int *) p_calloc(this->size_facearrays , 3*sizeof(int)); // [2400]
this->g_facestype = (int *) p_calloc(this->size_facearrays , sizeof(int));
this->g_faceverticeslist = (int *) p_calloc(this->size_facevertexarrays , 6*sizeof(int)); // [21000]
this->g_edge_angles = (double *)p_calloc(this->size_facevertexarrays , sizeof(double)); // [3500]
this->g_ev = (int *) p_calloc(this->size_ev , sizeof(int));
if ( !this->g_facesdata || !this->g_facestype || !this->g_hashtable || !this->g_polyhedronfirstfaceoffset || !this->g_polyhedronfaceindices || !this->g_faceverticeslist || !this->g_intworkarray || !this->g_doubleworkarray || !this->g_edge_angles || !this->g_normals || !this->g_ev ) {
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
}
goto out_of_memory;
}
// N_ORIGINAL_VERTICES - number of original vertex coordinates (i.e. total number of polyhedron points without any duplicated points for different polygons!)
// NFACE - number of faces in decomposition
// NPOLH - number of polyhedra in decomposition
this->n_original_vertices = params->nvc;
this->nface = params->nface;
this->npolh = 1; // if changed to anything higher than 1 you will have to adjust the variable 'this->size_polyhedronfirstfaceoffset' accordingly!
// -----------------------------------------------------------------------
// Initializing polyhedral decomposition data structure.
// -----------------------------------------------------------------------
// init 'vertex coordinate list'
this->g_vcl = params->vcl;
// init 'face pointer' list (offsets for each face into faceverticeslist)
this->g_facesdata = params->facep;
// set face type for each face to ZERO
for (i=0; i<this->nface; i++) {
this->g_facestype[i] = 0;
}
this->n_work_vertices = this->g_facesdata[this->nface*3] - 1;
// face list: offsets of (face defining) points in VCL
for (i=0; i<this->n_work_vertices; i++) {
this->g_faceverticeslist[i*6] = params->fvl[i];
}
// offsets into face list for each polyhedron (we will only process ONE polyhedron!)
this->g_polyhedronfirstfaceoffset[0] = 1;
this->g_polyhedronfirstfaceoffset[1] = this->nface+1;
this->n_polyhedronfaces = this->g_polyhedronfirstfaceoffset[this->npolh] - 1;
while ( ((2+this->n_polyhedronfaces)*1) > this->size_polyhedronfaceindices ) { // 2000
int res = increase_memory((void **)&this->g_polyhedronfaceindices, &this->size_polyhedronfaceindices, 2*sizeof(int));
if ( res == 0 ) {
this->ierr = 500;
goto GEOMPACK_abort;
}
// size_polyhedronfaceindices *= 2;
this->size_polyhedronfaceindices += 1024;
}
// init 'this->g_polyhedronfaceindices' (?)... we will simply set these values to the number of the
// corresponding face.
for (i=1; i<=this->n_polyhedronfaces; i++) {
this->g_polyhedronfaceindices[(i<<1)-2] = i;
}
this->hashtable_size = min(prime_(this->n_original_vertices + 2), this->hashtable_maxsize);
// ***********************************************************************
// -----------------------------------------------------------------------
// Init data structure
// -----------------------------------------------------------------------
dsphdc_();
if (this->ierr != 0) {
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
if ( this->ierr == 500 ) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to above error.\n\n");
}
}
goto GEOMPACK_abort;
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
int n_reflex_edges;
double minimum_angle;
int mem_iwa;
int mem_dwa;
int mem_vcl;
int mem_pffl;
int mem_pfil;
int mem_fl;
int mem_fvl;
int mem_total;
// calculate some statistical values
n_reflex_edges = 0;
minimum_angle = IVP_PI * 2.0f; // set minimum angle to 2*pi
for (i=0; i<this->n_work_vertices; i++) {
if (this->g_edge_angles[i] > IVP_PI + this->tolerance) {
n_reflex_edges++;
}
if (this->g_edge_angles[i] > -1.0) {
// Computing minimum angle in convex decomposition
minimum_angle = min(minimum_angle, this->g_edge_angles[i]);
}
}
minimum_angle = minimum_angle * 180.0f / IVP_PI;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Statistics after initializing polyhedral decomposition data structure:\n");
mem_iwa = this->size_intworkarray*sizeof(int);
mem_dwa = this->size_doubleworkarray*sizeof(double);
mem_vcl = this->size_vcl*3*sizeof(double);
mem_pffl = this->size_polyhedronfirstfaceoffset*sizeof(int);
mem_pfil = this->size_polyhedronfaceindices*2*sizeof(int);
mem_fl = this->size_facearrays*sizeof(int)+this->size_facearrays*3*sizeof(int)+this->size_facearrays*3*sizeof(double);
mem_fvl = this->size_facevertexarrays*6*sizeof(int)+this->size_facevertexarrays*sizeof(double);
mem_total = mem_iwa+ mem_dwa + mem_vcl + mem_pffl + mem_pfil + mem_fl + mem_fvl;
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for int WORK ARRAY: %d bytes\n" , mem_iwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for DOUBLE WORK ARRAY: %d bytes\n" , mem_dwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for VERTEX COORDINATE LIST: %d bytes\n" , mem_vcl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FIRST FACE LIST: %d bytes\n", mem_pffl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FACE INDEX LIST: %d bytes\n", mem_pfil);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE LISTS: %d bytes\n" , mem_fl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE VERTICES LISTS: %d bytes\n" , mem_fvl);
}
else {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Total memory allocated: %d bytes\n", mem_total);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES = %d\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE = %d\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES = %d\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH = %d\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_POLYHEDRONFACES = %d\n", this->n_polyhedronfaces);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_REFLEX_EDGES = %d\n", n_reflex_edges);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "MINIMUM_ANGLE = %f\n", minimum_angle);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n");
}
}
// -----------------------------------------------------------------------
// Decompose polyhedral region into convex parts.
// -----------------------------------------------------------------------
retry_counter = 1;
Retry_convex_decomposition:
// ***********************************************************************
this->cvdec3_();
if ( (this->ierr != 0) && (this->ierr != 327) ) { // abort on error but skip "reflex edge" resolving problems
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
if ( this->ierr == 500 ) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "*** GEOMPACK: Out of memory!\n\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to above error.\n\n");
}
}
goto GEOMPACK_abort;
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
int n_reflex_edges;
double minimum_angle;
int mem_iwa;
int mem_dwa;
int mem_vcl;
int mem_pffl;
int mem_pfil;
int mem_fl;
int mem_fvl;
int mem_total;
// calculate some statistical values
n_reflex_edges = 0;
minimum_angle = IVP_PI * 2.0f; // set minimum angle to 2*pi
for (i=0; i<this->n_work_vertices; i++) {
if (this->g_edge_angles[i] > IVP_PI + this->tolerance) {
n_reflex_edges++;
}
if (this->g_edge_angles[i] > -1.0) {
// Computing minimum angle in convex decomposition
minimum_angle = min(minimum_angle, this->g_edge_angles[i]);
}
}
minimum_angle = minimum_angle * 180.0f / IVP_PI;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Intermediate decomposition statistics:\n");
mem_iwa = this->size_intworkarray*sizeof(int);
mem_dwa = this->size_doubleworkarray*sizeof(double);
mem_vcl = this->size_vcl*3*sizeof(double);
mem_pffl = this->size_polyhedronfirstfaceoffset*sizeof(int);
mem_pfil = this->size_polyhedronfaceindices*2*sizeof(int);
mem_fl = this->size_facearrays*sizeof(int)+this->size_facearrays*3*sizeof(int)+this->size_facearrays*3*sizeof(double);
mem_fvl = this->size_facevertexarrays*6*sizeof(int)+this->size_facevertexarrays*sizeof(double);
mem_total = mem_iwa+ mem_dwa + mem_vcl + mem_pffl + mem_pfil + mem_fl + mem_fvl;
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for int WORK ARRAY: %d bytes\n" , mem_iwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for DOUBLE WORK ARRAY: %d bytes\n" , mem_dwa);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for VERTEX COORDINATE LIST: %d bytes\n" , mem_vcl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FIRST FACE LIST: %d bytes\n", mem_pffl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for POLYHEDRON FACE INDEX LIST: %d bytes\n", mem_pfil);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE LISTS: %d bytes\n" , mem_fl);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "Memory allocated for FACE VERTICES LISTS: %d bytes\n" , mem_fvl);
}
else {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Total memory allocated: %d bytes\n", mem_total);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES = %d\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE = %d\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES = %d\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH = %d\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_POLYHEDRONFACES = %d\n", this->n_polyhedronfaces);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_REFLEX_EDGES = %d\n", n_reflex_edges);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "MINIMUM_ANGLE = %f\n", minimum_angle);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n");
}
}
if (this->ierr == 327) { // unresolved reflex edge
if (retry_counter < 36) { // orig. 3
this->angacc -= IVP_PI / 36.0; // orig. 36.0
if (this->angacc > 0.0) {
this->rdacc *= 0.95;
this->ierr = 0;
retry_counter++;
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Retrying with <angacc=%f> and <rdacc=%f>\n\n", this->angacc, this->rdacc);
}
}
goto Retry_convex_decomposition;
}
}
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Premature abort due to difficulties in resolving some reflex edge(s).\n\n");
}
}
goto GEOMPACK_abort;
}
// -----------------------------------------------------------------------
// Final output.
// -----------------------------------------------------------------------
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "+++ Convex decomposition successful!\n\n");
}
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL2) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "VCL (vertex coordinate list)\n");
for (i=1; i<=this->n_original_vertices; i++) {
int j;
printf("#%d : \t", i);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%f ", this->g_vcl[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
for (i=1; i<=this->nface; i++) {
int j;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "i=%d\tfacesdata={", i);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%d ", this->g_facesdata[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "} facestype[%d]=%d\tnormals={", i-1, this->g_facestype[i-1]);
for (j=1; j<=3; j++) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%f ", this->g_normals[j+(i*3)-4]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n");
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n\n");
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "FaceVertexList >>FVL<<\n");
for (i=1; i<=this->n_work_vertices; i++) {
int j;
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "#%d\t", i);
for (j=1; j<=6; j++) {
switch (j) {
case 1:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "LOC = ");
break;
case 2:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "FACN = ");
break;
case 3:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "SUCC = ");
break;
case 4:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "PRED = ");
break;
case 5:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "EDGA = ");
break;
case 6:
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "EDGC = ");
break;
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "%d\t", this->g_faceverticeslist[j+(i*6)-7]);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\t(%f Grad)\n", this->g_edge_angles[i-1]/IVP_PI*180.0);
}
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL2, "\n\n");
}
#if 0
s_wsfe(&io___90);
for (i=0; i<this->npolh; i++) {
do_fio(1, (char *)&this->g_polyhedronfirstfaceoffset[i], (ftnlen)sizeof(int));
}
e_wsfe();
s_wsfe(&io___91);
for (i__ = 1; i__ <= this->n_polyhedronfaces; i__++) {
int j;
do_fio(1, (char *)&i__, (ftnlen)sizeof(int));
for (j=1; j<=2; j++) {
do_fio(1, (char *)&this->g_polyhedronfaceindices[j + (i__ << 1) - 3], (ftnlen)
sizeof(int));
}
}
e_wsfe();
#endif
}
GEOMPACK_abort:
IVP_IF(1) {
IVP_IFDEBUG(IVP_DM_GEOMPACK_LEVEL1) {
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "Final GEOMPACK statistics:\n");
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_ORIGINAL_VERTICES \t= %d (number of vertex coordinates)\n", this->n_original_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NFACE \t= %d (number of faces in polyhedral decomposition)\n", this->nface);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "N_WORK_VERTICES \t= %d (number of positions used in FVL array)\n", this->n_work_vertices);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "NPOLH \t= %d (number of polyhedra in decomposition)\n", this->npolh);
ivp_debugmanager.dprint(IVP_DM_GEOMPACK_LEVEL1, "\n\n");
}
}
*n_original_vertices_out = this->n_original_vertices;
*nface_out = this->nface;
*n_work_vertices_out = this->n_work_vertices;
*npolh_out = this->npolh;
*facep_out = &this->g_facesdata[0];
*fvl_out = &this->g_faceverticeslist[0];
*vcl_out = &this->g_vcl[0];
out_of_memory:
P_FREE(this->g_facestype);
P_FREE(this->g_hashtable);
P_FREE(this->g_polyhedronfirstfaceoffset);
P_FREE(this->g_polyhedronfaceindices);
P_FREE(this->g_intworkarray);
P_FREE(this->g_doubleworkarray);
P_FREE(this->g_edge_angles);
P_FREE(this->g_normals);
P_FREE(this->g_ev);
return;
}
| 42.04898 | 289 | 0.625315 | DannyParker0001 |
b45164c4ea436932bc0693a779e65670c40426da | 4,772 | cpp | C++ | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | 1 | 2017-05-07T00:58:10.000Z | 2017-05-07T00:58:10.000Z | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | null | null | null | src/framework/graphics/particleaffector.cpp | Cayan/otclient | 36c1ea9245c614dad50b073d67d32afd2727e9ef | [
"MIT"
] | null | null | null | /*
* Copyright (c) 2010-2012 OTClient <https://github.com/edubart/otclient>
*
* 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 "particle.h"
#include "particleaffector.h"
#include <framework/core/clock.h>
ParticleAffector::ParticleAffector()
{
m_active = false;
m_finished = false;
m_delay = 0;
m_duration = 0;
m_elapsedTime = 0;
}
void ParticleAffector::update(float elapsedTime)
{
if(m_duration >= 0 && m_elapsedTime >= m_duration + m_delay) {
m_finished = true;
return;
}
if(!m_active && m_elapsedTime > m_delay)
m_active = true;
m_elapsedTime += elapsedTime;
}
bool ParticleAffector::load(const OTMLNodePtr& node)
{
float minDelay = 0, maxDelay = 0;
float minDuration = -1, maxDuration = -1;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "delay") {
minDelay = childNode->value<float>();
maxDelay = childNode->value<float>();
}
else if(childNode->tag() == "min-delay")
minDelay = childNode->value<float>();
else if(childNode->tag() == "max-delay")
maxDelay = childNode->value<float>();
if(childNode->tag() == "duration") {
minDuration = childNode->value<float>();
maxDuration = childNode->value<float>();
}
else if(childNode->tag() == "min-duration")
minDuration = childNode->value<float>();
else if(childNode->tag() == "max-duration")
maxDuration = childNode->value<float>();
}
m_delay = Fw::randomRange(minDelay, maxDelay);
m_duration = Fw::randomRange(minDuration, maxDuration);
return true;
}
bool GravityAffector::load(const OTMLNodePtr& node)
{
if(!ParticleAffector::load(node))
return false;
m_angle = 270 * DEG_TO_RAD;
m_gravity = 9.8;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "angle")
m_angle = childNode->value<float>() * DEG_TO_RAD;
else if(childNode->tag() == "gravity")
m_gravity = childNode->value<float>();
}
return true;
}
void GravityAffector::updateParticle(const ParticlePtr& particle, float elapsedTime)
{
if(!m_active)
return;
PointF velocity = particle->getVelocity();
velocity += PointF(m_gravity * elapsedTime * cos(m_angle), m_gravity * elapsedTime * sin(m_angle));
particle->setVelocity(velocity);
}
bool AttractionAffector::load(const OTMLNodePtr& node)
{
if(!ParticleAffector::load(node))
return false;
m_acceleration = 32;
m_reduction = 0;
m_repelish = false;
for(const OTMLNodePtr& childNode : node->children()) {
if(childNode->tag() == "position")
m_position = childNode->value<Point>();
else if(childNode->tag() == "acceleration")
m_acceleration = childNode->value<float>();
else if(childNode->tag() == "velocity-reduction-percent")
m_reduction = childNode->value<float>();
else if(childNode->tag() == "repelish")
m_repelish = childNode->value<bool>();
}
return true;
}
void AttractionAffector::updateParticle(const ParticlePtr& particle, float elapsedTime)
{
if(!m_active)
return;
PointF pPosition = particle->getPosition();
PointF d = PointF(m_position.x - pPosition.x, pPosition.y - m_position.y);
if(d.length() == 0)
return;
PointF direction = PointF(1, 1);
if(m_repelish)
direction = PointF(-1, -1);
PointF pVelocity = particle->getVelocity() + (d / d.length() * m_acceleration * elapsedTime) * direction;
particle->setVelocity(pVelocity - pVelocity * m_reduction/100.0 * elapsedTime);
}
| 32.684932 | 109 | 0.652347 | Cayan |
b453f30cb136b59fb690154bb07e569a718bb9b8 | 8,327 | cc | C++ | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 6 | 2020-02-06T01:08:55.000Z | 2020-02-11T14:44:25.000Z | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 25 | 2020-02-03T13:28:20.000Z | 2021-09-02T07:48:32.000Z | src/source_wrap.cc | gurumlab/simplemedia | 503854edc83449b132b3fdfdbb1d20ba8488d293 | [
"MIT"
] | 1 | 2020-03-03T01:44:40.000Z | 2020-03-03T01:44:40.000Z | #include "source_wrap.h"
#include <napi.h>
#include <uv.h>
#include "log_message.h"
Napi::FunctionReference Source::constructor;
Napi::Object Source::Init(Napi::Env env, Napi::Object exports) {
Napi::HandleScope scope(env);
constexpr auto name = "_Source";
Napi::Function func =
DefineClass(env,
name,
{
InstanceMethod("prepare", &Source::Prepare),
InstanceMethod("start", &Source::Start),
InstanceMethod("stop", &Source::Stop),
InstanceMethod("pause", &Source::Pause),
InstanceMethod("seek", &Source::Seek),
InstanceMethod("requestPidChannel", &Source::RequestPidChannel),
InstanceMethod("findStream", &Source::FindStream),
InstanceAccessor("datasource", &Source::dataSource, &Source::SetDataSource),
InstanceAccessor("audioPid", &Source::audioPid, nullptr),
InstanceAccessor("hasAudio", &Source::hasAudio, nullptr),
InstanceAccessor("videoPid", &Source::videoPid, nullptr),
InstanceAccessor("hasVideo", &Source::hasVideo, nullptr),
InstanceAccessor("trace", &Source::log_enabled, &Source::EnableLog),
InstanceAccessor("duration", &Source::duration, nullptr),
});
constructor = Napi::Persistent(func);
constructor.SuppressDestruct();
exports.Set(name, func);
return exports;
}
Source::Source(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Source>(info) {
if(log_enabled_) LOG(INFO) << __func__;
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
source_.reset(new gurum::Source);
}
void Source::SetDataSource(const Napi::CallbackInfo& info, const Napi::Value &value) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !value.IsString()) {
Napi::TypeError::New(env, "String expected").ThrowAsJavaScriptException();
return;
}
source_->SetDataSource(value.ToString().Utf8Value());
}
Napi::Value Source::dataSource(const Napi::CallbackInfo& info) {
return Napi::String::New(info.Env(), source_->dataSource());
}
Napi::Value Source::audioPid(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->audioPid());
}
Napi::Value Source::hasAudio(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), source_->HasAudio());
}
Napi::Value Source::videoPid(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->videoPid());
}
Napi::Value Source::hasVideo(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), source_->HasVideo());
}
Napi::Value Source::Prepare(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
auto root = Napi::Object::New(env);
auto format = Napi::Object::New(env);
const AVFormatContext *fmt = source_->Prepare();
format["native"] = Napi::External<AVFormatContext>::New(env, (AVFormatContext *)fmt);
format["duration"] = fmt->duration;
AVDictionary* meta_data = fmt->metadata;
AVDictionaryEntry* entry = NULL;
while ((entry = av_dict_get((const AVDictionary*)meta_data, "", entry, AV_DICT_IGNORE_SUFFIX))) {
format[entry->key] = entry->value;
}
root["format"] = format;
auto streams = Napi::Array::New(env, fmt->nb_streams);
for (int i = 0; i < (int)fmt->nb_streams; i++) {
auto stream = Napi::Object::New(env);
AVStream *strm = fmt->streams[i];
stream["native"] = Napi::External<AVStream>::New(env, strm);
AVCodecParameters *codec_param = strm->codecpar;
stream["duration"] = Napi::Number::New(env, strm->duration);
AVCodecID codec_id = codec_param->codec_id;
stream["codec"] = Napi::String::New(env, avcodec_get_name(codec_id));
stream["bitrate"] = Napi::Number::New(env, codec_param->bit_rate);
stream["channels"] = Napi::Number::New(env, codec_param->channels);
stream["samplerate"] = Napi::Number::New(env, codec_param->sample_rate);
AVDictionary* meta_data = strm->metadata;
while ((entry = av_dict_get((const AVDictionary*)meta_data, "", entry, AV_DICT_IGNORE_SUFFIX))) {
stream[entry->key] = Napi::String::New(env, entry->value);
}
streams[i] = stream;
}
root["streams"] = streams;
return root;
}
void Source::Start(const Napi::CallbackInfo& info) {
assert(source_);
source_->Start();
}
void Source::Stop(const Napi::CallbackInfo& info) {
assert(source_);
source_->Stop();
}
void Source::Pause(const Napi::CallbackInfo& info) {
assert(source_);
source_->Pause();
}
void Source::Seek(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !info[0].IsObject()) {
Napi::TypeError::New(env, "Object expected").ThrowAsJavaScriptException();
return;
}
Napi::Object obj = info[0].ToObject();
do {
if(!obj.HasOwnProperty("pos")) {
Napi::TypeError::New(env, "no pos").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["pos"]).IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return;
}
} while(0);
int64_t pos = (int64_t) static_cast<Napi::Value>(obj["pos"]).ToNumber();
do {
if(!obj.HasOwnProperty("backward")) {
Napi::TypeError::New(env, "no backward").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["backward"]).IsBoolean()) {
Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
return;
}
} while(0);
bool backward = static_cast<Napi::Value>(obj["backward"]).ToBoolean();
do {
if(!obj.HasOwnProperty("callback")) {
Napi::TypeError::New(env, "no callback").ThrowAsJavaScriptException();
return;
}
if(!static_cast<Napi::Value>(obj["callback"]).IsFunction()) {
Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
return;
}
} while(0);
int flag = backward ? AVSEEK_FLAG_BACKWARD : 0;
assert(source_);
source_->Seek(pos, flag, [&]{
auto callback = static_cast<Napi::Value>(obj["callback"]).As<Napi::Function>();
callback.Call(env.Global(), {});
});
}
Napi::Value Source::RequestPidChannel(const Napi::CallbackInfo& info){
Napi::Env env = info.Env();
if (info.Length() <= 0) {
Napi::TypeError::New(env, "Object expected").ThrowAsJavaScriptException();
return env.Undefined();
}
Napi::Value value;
if (info[0].IsObject()) {
Napi::Object obj = info[0].ToObject();
if(!obj.HasOwnProperty("pid")) {
Napi::TypeError::New(env, "no pid").ThrowAsJavaScriptException();
return env.Undefined();
}
value = obj["pid"];
if(! value.IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
}
else if(info[0].IsNumber()) {
value = info[0].ToNumber();
}
else {
Napi::TypeError::New(env, "Object | Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
Napi::Number number = value.As<Napi::Number>();
int pid = (int) number;
auto pidchannel = source_->RequestPidChannel(pid);
assert(pidchannel);
return Napi::External<gurum::PidChannel>::New(env, pidchannel);
}
Napi::Value Source::FindStream(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !info[0].IsNumber()) {
Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
return env.Undefined();
}
int pid = (int) info[0].ToNumber();
auto stream = source_->FindStream(pid);
assert(stream);
return Napi::External<AVStream>::New(env, stream);
}
void Source::EnableLog(const Napi::CallbackInfo& info, const Napi::Value &value) {
Napi::Env env = info.Env();
if (info.Length() <= 0 || !value.IsBoolean()) {
Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
return;
}
log_enabled_ = value.ToBoolean();
if(source_) source_->EnableLog(log_enabled_);
}
Napi::Value Source::log_enabled(const Napi::CallbackInfo& info) {
return Napi::Boolean::New(info.Env(), log_enabled_);
}
Napi::Value Source::duration(const Napi::CallbackInfo& info) {
return Napi::Number::New(info.Env(), source_->GetDuration());
} | 32.654902 | 101 | 0.646691 | gurumlab |
b4559a4bbfd577a4dfc79b5b8d4c42b6eb9bf1e0 | 854 | cpp | C++ | MyCurve25519/MyCurve25519/ed25519/sign.cpp | BayrakMustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 18 | 2016-04-04T16:09:17.000Z | 2017-09-02T02:55:55.000Z | MyCurve25519/MyCurve25519/ed25519/sign.cpp | bayrakmustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 12 | 2016-04-07T02:48:24.000Z | 2017-04-11T11:19:58.000Z | MyCurve25519/MyCurve25519/ed25519/sign.cpp | bayrakmustafa/WhatsApp-API-NET | 39b37aeb9a98c6eb338ceea20c9d4cab2bdb12e7 | [
"MIT"
] | 9 | 2017-12-06T04:16:16.000Z | 2021-06-17T09:18:47.000Z | #include "pch.h"
#include <string.h>
#include "nacl_includes\crypto_sign.h"
#include "additions\crypto_hash_sha512.h"
#include "ge.h"
#include "sc.h"
int crypto_sign(
unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long mlen,
const unsigned char *sk
)
{
unsigned char pk[32];
unsigned char az[64];
unsigned char nonce[64];
unsigned char hram[64];
ge_p3 R;
memmove(pk, sk + 32, 32);
crypto_hash_sha512(az, sk, 32);
az[0] &= 248;
az[31] &= 63;
az[31] |= 64;
*smlen = mlen + 64;
memmove(sm + 64, m, mlen);
memmove(sm + 32, az + 32, 32);
crypto_hash_sha512(nonce, sm + 32, mlen + 32);
memmove(sm + 32, pk, 32);
sc_reduce(nonce);
ge_scalarmult_base(&R, nonce);
ge_p3_tobytes(sm, &R);
crypto_hash_sha512(hram, sm, mlen + 64);
sc_reduce(hram);
sc_muladd(sm + 32, hram, az, nonce);
return 0;
} | 20.333333 | 49 | 0.667447 | BayrakMustafa |
b455ceae3e79cee92de6c620b0d64d23f62c6d62 | 630 | hpp | C++ | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | null | null | null | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | 1 | 2018-04-18T01:17:01.000Z | 2018-08-06T15:34:33.000Z | Dist/Headers/glitter.hpp | gabrielrodriguesrocha/Projeto-CG | b679d2e7b3572e3d0de137ec448fc170346dc21e | [
"MIT"
] | 2 | 2018-04-12T21:41:19.000Z | 2018-04-13T01:41:45.000Z | // Preprocessor Directives
#ifndef GLITTER
#define GLITTER
#pragma once
// System Headers
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <btBulletDynamicsCommon.h>
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// Reference: https://github.com/nothings/stb/blob/master/stb_image.h#L4
// To use stb_image, add this in *one* C++ source file.
// #define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
// Define Some Constants
const int mWidth = 1280;
const int mHeight = 800;
#endif //~ Glitter Header
| 24.230769 | 72 | 0.746032 | gabrielrodriguesrocha |
b45657b78fd435544b441cb78fc8c5b9c9ce44b4 | 147,876 | cpp | C++ | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 107 | 2018-08-16T05:32:52.000Z | 2022-02-11T19:44:25.000Z | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 3 | 2018-11-04T05:09:32.000Z | 2019-07-16T19:18:42.000Z | src/AutoSchedule.cpp | jrk/gradient-halide | c66610a8ac9a4241421c9eedb2f0fdae2e26a4b1 | [
"MIT"
] | 16 | 2018-08-21T09:45:13.000Z | 2021-12-11T03:32:15.000Z | #include <algorithm>
#include <regex>
#include "AutoSchedule.h"
#include "AutoScheduleUtils.h"
#include "ExprUsesVar.h"
#include "FindCalls.h"
#include "Func.h"
#include "IREquality.h"
#include "Inline.h"
#include "ParallelRVar.h"
#include "RealizationOrder.h"
#include "RegionCosts.h"
#include "Scope.h"
#include "Simplify.h"
#include "Util.h"
namespace Halide {
namespace Internal {
using std::deque;
using std::make_pair;
using std::map;
using std::pair;
using std::set;
using std::string;
using std::vector;
namespace {
// Substitute parameter estimates into the exprs describing the box bounds.
void substitute_estimates_box(Box &box) {
box.used = subsitute_var_estimates(box.used);
for (auto &b : box.bounds) {
b.min = subsitute_var_estimates(b.min);
b.max = subsitute_var_estimates(b.max);
}
}
// Substitute parameter estimates into the boxes in 'region'.
void substitute_estimates_region(map<string, Box> ®ion) {
for (auto &iter : region) {
substitute_estimates_box(iter.second);
}
}
// Return true if any of the box dimension is unbounded.
bool is_box_unbounded(const Box &b) {
for (size_t i = 0; i < b.size(); i++) {
if (!b[i].is_bounded()) {
return true;
}
}
return false;
}
// Helper function to simplify the upper and lower bounds of each dimension of a box.
void simplify_box(Box &b) {
for (size_t i = 0; i < b.size(); i++) {
b[i].min = simplify(b[i].min);
b[i].max = simplify(b[i].max);
}
}
// Helper function to merge the partial region map into the result region map.
void merge_regions(map<string, Box> &result, const map<string, Box> &partial) {
// Merge regions from 'partial' with an existing region in 'result'.
for (const auto ® : partial) {
auto iter = result.find(reg.first);
if (iter == result.end()) {
result.emplace(reg.first, reg.second);
} else {
merge_boxes(iter->second, reg.second);
}
}
}
// Replace all occurrences of non-alphanumeric chars in 'name' with '_'.
string get_sanitized_name(string name) {
if (isdigit(name[0])) {
name = "_" + name;
}
for (size_t i = 0; i < name.size(); ++i) {
if (!isalnum(name[i])) {
name[i] = '_';
}
}
return name;
}
// Representation of a function stage in the pipeline.
struct FStage {
Function func;
uint32_t stage_num;
FStage(Function func, uint32_t stage_num) : func(func), stage_num(stage_num) {}
bool operator==(const FStage &other_stage) const {
return (func.name() == other_stage.func.name()) &&
(stage_num == other_stage.stage_num);
}
bool operator<(const FStage &other_stage) const {
return func.name() < other_stage.func.name() ||
((func.name() == other_stage.func.name()) &&
(stage_num < other_stage.stage_num));
}
friend std::ostream& operator<<(std::ostream &stream, const FStage &s) {
if (s.stage_num == 0) {
stream << s.func.name();
} else {
stream << s.func.name() << ".update(" << (s.stage_num - 1) << ")";
}
return stream;
}
};
struct DependenceAnalysis {
// Map containing all the functions in the pipeline.
map<string, Function> env;
vector<string> order;
FuncValueBounds func_val_bounds;
struct RegionsRequiredQuery {
string f;
int stage;
set<string> prods;
bool only_regions_computed;
RegionsRequiredQuery(const string &f, int stage, const set<string> &prods,
bool only_regions_computed)
: f(f), stage(stage), prods(prods),
only_regions_computed(only_regions_computed) {}
bool operator==(const RegionsRequiredQuery &other) const {
return (f == other.f) && (stage == other.stage) && (prods == other.prods) &&
(only_regions_computed == other.only_regions_computed);
}
bool operator<(const RegionsRequiredQuery &other) const {
if (f < other.f) {
return true;
} else if (f > other.f) {
return false;
}
if (stage < other.stage) {
return true;
} else if (stage > other.stage) {
return false;
}
if (only_regions_computed < other.only_regions_computed) {
return true;
} else if (only_regions_computed > other.only_regions_computed) {
return false;
}
return prods < other.prods;
}
};
struct RegionsRequired {
DimBounds bounds;
// Regions required to compute 'bounds' given a particular
// RegionsRequiredQuery.
map<string, Box> regions;
RegionsRequired(const DimBounds &b, const map<string, Box> &r)
: bounds(b), regions(r) {}
};
// Cache for bounds queries (bound queries with the same parameters are
// common during the grouping process).
map<RegionsRequiredQuery, vector<RegionsRequired>> regions_required_cache;
DependenceAnalysis(const map<string, Function> &env, const vector<string> &order,
const FuncValueBounds &func_val_bounds)
: env(env), order(order), func_val_bounds(func_val_bounds) {}
// Return the regions of the producers ('prods') required to compute the region
// of the function stage ('f', 'stage_num') specified by 'bounds'. When
// 'only_regions_computed' is set to true, this only returns the computed
// regions and not the total allocated regions.
map<string, Box> regions_required(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return the regions of the producers ('prods') required to compute the region
// of the function specified by 'pure_bounds'. When 'only_regions_computed'
// is set to true, this only returns the computed regions and not the total
// allocated regions.
map<string, Box> regions_required(Function f,
const DimBounds &pure_bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return redundantly computed regions of producers ('prods') while computing
// a region of the function stage ('f', 'stage_num') specified by 'bounds'.
// 'var' is the dimension along which redundant computation is accounted for.
// When 'only_regions_computed' is set to true, this only returns the computed
// regions and not the total allocated regions. When 'only_regions_computed'
// is set to true, this only returns the computed regions and not the total
// allocated regions.
map<string, Box> redundant_regions(Function f, int stage_num, string var,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates);
// Return overlapping regions of producers ('prods') while computing a function
// stage along each of the dimensions.
vector<map<string, Box>>
overlap_regions(Function f, int stage_num, const DimBounds &bounds,
const set<string> &prods, bool only_regions_computed,
const Scope<Interval> *input_estimates);
};
// Return the regions of the producers ('prods') required to compute the region
// of the function specified by 'pure_bounds'.
map<string, Box>
DependenceAnalysis::regions_required(Function f, const DimBounds &pure_bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Find the regions required for each stage and merge them.
map<string, Box> regions;
int num_stages = f.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
DimBounds bounds = get_stage_bounds(f, s, pure_bounds);
map<string, Box> stage_regions =
regions_required(f, s, bounds, prods, only_regions_computed, input_estimates);
merge_regions(regions, stage_regions);
}
return regions;
}
struct StageBounds {
FStage f_stage;
DimBounds bounds;
StageBounds(const FStage &fs, const DimBounds &b) : f_stage(fs), bounds(b) {}
StageBounds(Function func, uint32_t stage_num, const DimBounds &b) :
f_stage(FStage(func, stage_num)), bounds(b) {}
bool operator==(const StageBounds &other) const {
return (f_stage == other.f_stage) && (bounds == other.bounds);
}
bool operator<(const StageBounds &other) const {
return (f_stage < other.f_stage) ||
((f_stage == other.f_stage) && (bounds.size() < other.bounds.size()));
}
friend std::ostream& operator<<(std::ostream &stream, const StageBounds &s) {
stream << "Stage: " << s.f_stage << "\n";
stream << "Bounds:\n";
for (const auto &iter : s.bounds) {
stream << "\t" << iter.first << " -> [" << iter.second.min << ", " << iter.second.max << "]\n";
}
stream << "\n";
return stream;
}
};
// Helper function to queue regions that need to be traversed. 'fs_bounds' is
// the queue into which the regions specified by 'prod_func' and 'region'
// will be added.
void queue_func_regions(map<FStage, DimBounds> &fs_bounds,
const Function &prod_func, const Box ®ion,
const set<StageBounds>& visited) {
DimBounds prod_pure_bounds;
const vector<string> &args = prod_func.args();
internal_assert(region.size() == args.size());
// The region only specifies the extent of each dimension
// by position. Populating a map which is keyed by name.
for (size_t v = 0; v < args.size(); v++) {
prod_pure_bounds[args[v]] = region[v];
}
// Get the bounds of all stages in a function from the
// bounds on the pure dimensions.
vector<DimBounds> prod_bounds = get_stage_bounds(prod_func, prod_pure_bounds);
size_t num_stages = prod_func.updates().size() + 1;
internal_assert(prod_bounds.size() == num_stages);
// Add all stages of a function into the queue.
for (size_t prod_s = 0; prod_s < num_stages; prod_s++) {
StageBounds sb(prod_func, prod_s, prod_bounds[prod_s]);
if (visited.find(sb) == visited.end()) {
auto iter = fs_bounds.find(sb.f_stage);
if (iter == fs_bounds.end()) {
fs_bounds.emplace(sb.f_stage, sb.bounds);
} else {
for (const auto &b : sb.bounds) {
DimBounds &curr_bounds = iter->second;
auto b_iter = curr_bounds.find(b.first);
if (b_iter == curr_bounds.end()) {
curr_bounds.emplace(b.first, b.second);
} else {
if (b_iter->second.has_lower_bound() && b.second.has_lower_bound()) {
b_iter->second.min = simplify(Interval::make_min(b_iter->second.min, b.second.min));
} else {
b_iter->second.min = Interval::neg_inf;
}
if (b_iter->second.has_upper_bound() && b.second.has_upper_bound()) {
b_iter->second.max = simplify(Interval::make_max(b_iter->second.max, b.second.max));
} else {
b_iter->second.max = Interval::pos_inf;
}
}
}
}
}
}
}
// Helper function for merging 'curr_regions' to the global map of regions
// and adding them to the queue of regions that need to be traversed.
// 'prods' is the set of producer functions that are under consideration.
void merge_and_queue_regions(map<FStage, DimBounds> &fs_bounds,
map<string, Box> ®ions,
map<string, Box> &curr_regions,
const set<string> &prods,
const map<string, Function> &env,
bool only_regions_computed,
string curr_func_name,
const set<StageBounds>& visited) {
for (const auto ® : curr_regions) {
// Merge region with an existing region of a function in the
// global map. Do not merge the parent function itself to the region
// when querying only for the values computed.
if (!only_regions_computed || (only_regions_computed && (reg.first != curr_func_name))) {
auto iter = regions.find(reg.first);
if (iter == regions.end()) {
regions.emplace(reg.first, reg.second);
} else {
merge_boxes(iter->second, reg.second);
}
}
// Skip adding the current region into to the queue if the function
// is not in 'prods'.
if (prods.find(reg.first) == prods.end()) {
continue;
}
const auto &it = env.find(reg.first);
if ((it != env.end()) && (reg.first != curr_func_name)) {
// Add all stages of the function representing the
// region into the queue.
queue_func_regions(fs_bounds, it->second, reg.second, visited);
}
}
}
// Return the regions of the producers ('prods') required to compute the region
// of the function stage ('f', 'stage_num') specified by 'bounds'.
map<string, Box>
DependenceAnalysis::regions_required(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Iteratively compute the required regions by traversing the chain
// of dependencies.
// Check the cache if we've already computed this previously.
RegionsRequiredQuery query(f.name(), stage_num, prods, only_regions_computed);
const auto &iter = regions_required_cache.find(query);
if (iter != regions_required_cache.end()) {
const auto &it = std::find_if(iter->second.begin(), iter->second.end(),
[&bounds](const RegionsRequired &r) { return (r.bounds == bounds); });
if (it != iter->second.end()) {
internal_assert((iter->first == query) && (it->bounds == bounds));
return it->regions;
}
}
// Map of all the required regions.
map<string, Box> regions;
map<FStage, DimBounds> fs_bounds;
set<StageBounds> visited;
// Add the query function and its region to the queue.
fs_bounds.emplace(FStage(f, stage_num), bounds);
while (!fs_bounds.empty()) {
for (int i = order.size() - 1; i >= 0; --i) {
const Function &f = env.find(order[i])->second;
int num_stages = f.updates().size() + 1;
for (int stage_num = 0; stage_num < num_stages; ++stage_num) {
FStage s(f, stage_num);
const auto &iter = fs_bounds.find(s);
if (iter == fs_bounds.end()) {
continue;
}
DimBounds curr_bounds = iter->second;
visited.insert(StageBounds(s, curr_bounds));
// Scope for containing all the estimates on parameters and intervals.
Scope<Interval> curr_scope;
curr_scope.set_containing_scope(input_estimates);
// If the function has an extern definition, there is no visibility into
// the expression defining the function. So the regions required will be
// the entire domain of the inputs to the extern func. Use the estimates
// on the inputs to the extern function if available.
//
// TODO: Query the extern function for bounds of the functions which it
// it depends on. This can be done by calling the extern func in the
// bounds query mode.
if (s.func.has_extern_definition()) {
for (const ExternFuncArgument &arg : s.func.extern_arguments()) {
if (arg.is_func()) {
// If the argument is an entire function, the bounds of the
// function required are unknown. Create an infinite region
// of the correct dimension, update the region map, and
// add it to the queue.
string prod_name = Function(arg.func).name();
const Function &prod_func = get_element(env, prod_name);
map<string, Box> prod_reg;
const vector<string> &args = prod_func.args();
for (size_t v = 0; v < args.size(); v++) {
prod_reg[prod_name].push_back(Interval());
}
merge_and_queue_regions(fs_bounds, regions, prod_reg, prods, env,
only_regions_computed, s.func.name(), visited);
} else if (arg.is_expr()) {
// Find the boxes required for the expression and add the regions
// to the queue.
Expr subs_arg = subsitute_var_estimates(arg.expr);
map<string, Box> arg_regions = boxes_required(subs_arg, curr_scope, func_val_bounds);
substitute_estimates_region(arg_regions);
merge_and_queue_regions(fs_bounds, regions, arg_regions, prods, env,
only_regions_computed, s.func.name(), visited);
} else if (arg.is_image_param() || arg.is_buffer()) {
// If the argument is an image or a buffer, the required
// bounds are unknown. Create an infinite region of the
// correct dimension and update the region map.
Buffer<> buf;
if (arg.is_image_param()) {
buf = arg.image_param.buffer();
} else {
buf = arg.buffer;
}
map<string, Box> buf_reg;
for (int v = 0; v < buf.dimensions(); v++) {
buf_reg[buf.name()].push_back(Interval());
}
merge_regions(regions, buf_reg);
}
}
} else {
Definition def = get_stage_definition(s.func, s.stage_num);
const vector<Dim> &dims = def.schedule().dims();
// Substitute parameter estimates into the bounds and add them to the
// current scope.
for (int d = 0; d < (int)dims.size() - 1; d++) {
Interval simple_bounds = get_element(curr_bounds, dims[d].var);
simple_bounds.min = subsitute_var_estimates(simple_bounds.min);
simple_bounds.max = subsitute_var_estimates(simple_bounds.max);
curr_scope.push(dims[d].var, simple_bounds);
}
// Find the regions required for each value of the current function stage,
// update the region map, and add them to the queue.
for (const auto &val : def.values()) {
// Substitute the parameter estimates into the expression and get
// the regions required for the expression.
Expr subs_val = subsitute_var_estimates(val);
map<string, Box> curr_regions = boxes_required(subs_val, curr_scope, func_val_bounds);
substitute_estimates_region(curr_regions);
// Arguments to the definition may require regions of functions.
// For example, update definitions in histograms where the bin is
// based on the value of a function.
Box left_reg;
for (const Expr &arg : def.args()) {
Expr subs_arg = subsitute_var_estimates(arg);
map<string, Box> arg_regions = boxes_required(subs_arg, curr_scope, func_val_bounds);
substitute_estimates_region(arg_regions);
// Merge the regions with the regions found while looking at
// the values.
merge_regions(curr_regions, arg_regions);
Interval arg_bounds = bounds_of_expr_in_scope(arg, curr_scope, func_val_bounds);
left_reg.push_back(arg_bounds);
}
auto iter_curr = curr_regions.find(s.func.name());
if (iter_curr == curr_regions.end()) {
curr_regions.emplace(s.func.name(), left_reg);
} else {
merge_boxes(iter_curr->second, left_reg);
}
// Update the region map, and add 'curr_regions' to the queue.
merge_and_queue_regions(fs_bounds, regions, curr_regions, prods, env,
only_regions_computed, s.func.name(), visited);
}
}
// Remove processed region from the queue.
fs_bounds.erase(iter);
}
}
}
// Simplify the bounds on each region and substitute global pipeline
// bounds for function regions which lower and upper bounds could not be
// determined.
map<string, Box> concrete_regions;
for (auto &f_reg : regions) {
simplify_box(f_reg.second);
Box concrete_box;
for (size_t i = 0; i < f_reg.second.size(); i++) {
Expr lower = f_reg.second[i].min;
Expr upper = f_reg.second[i].max;
auto iter = env.find(f_reg.first);
bool in_env = (iter != env.end());
if (!lower.as<IntImm>() && in_env) {
const Function &curr_f = iter->second;
for (const auto &b : curr_f.schedule().estimates()) {
size_t num_pure_args = curr_f.args().size();
if ((i < num_pure_args) && (b.var == curr_f.args()[i])) {
lower = b.min;
}
}
}
if (!upper.as<IntImm>() && in_env) {
const Function &curr_f = iter->second;
for (const auto &b : curr_f.schedule().estimates()) {
size_t num_pure_args = curr_f.args().size();
if ((i < num_pure_args) && (b.var == curr_f.args()[i])) {
const IntImm *bmin = b.min.as<IntImm>();
const IntImm *bextent = b.extent.as<IntImm>();
upper = IntImm::make(Int(32), bmin->value + bextent->value - 1);
}
}
}
Interval concrete_bounds = Interval(lower, upper);
concrete_box.push_back(concrete_bounds);
}
concrete_regions[f_reg.first] = concrete_box;
}
regions_required_cache[query].push_back(RegionsRequired(bounds, concrete_regions));
return concrete_regions;
}
// Return redundantly computed regions of producers ('prods') while computing a
// region of the function stage ('f', 'stage_num') specified by 'bounds'. 'var'
// is the dimension along which redundant computation is accounted for.
map<string, Box>
DependenceAnalysis::redundant_regions(Function f, int stage_num, string var,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
// Find the regions required to compute the region of 'f' specified
// by 'bounds'.
map<string, Box> regions = regions_required(
f, stage_num, bounds, prods, only_regions_computed, input_estimates);
// Shift the bounds by the size of the interval along the direction
// of var.
DimBounds shifted_bounds;
for (const auto &b : bounds) {
if (b.first == var) {
Expr len = b.second.max - b.second.min + 1;
Interval bound = Interval(b.second.min + len, b.second.max + len);
shifted_bounds[b.first] = bound;
} else {
shifted_bounds[b.first] = b.second;
}
}
// Find the regions required to compute the region of f specified
// by shifted_bounds.
map<string, Box> regions_shifted = regions_required(
f, stage_num, shifted_bounds, prods, only_regions_computed, input_estimates);
// Compute the overlaps between 'regions_shifted' and the original
// regions required.
map<string, Box> overlaps;
for (const auto ® : regions) {
auto iter = regions_shifted.find(reg.first);
if (iter == regions.end()) {
// It will be interesting to log cases where this actually happens
// i.e., the shifted regions do not contain a function that was
// there in the original regions.
continue;
}
const Box &b = reg.second;
const Box &b_shifted = iter->second;
// The boxes should be of the same size.
internal_assert(b.size() == b_shifted.size());
Box b_intersect;
for (uint32_t i = 0 ; i < b.size(); i++) {
b_intersect.push_back(Interval::make_intersection(b[i], b_shifted[i]));
}
// A function should appear once in the regions and therefore cannot
// already be present in the overlaps map.
internal_assert(overlaps.find(reg.first) == overlaps.end());
overlaps.emplace(reg.first, b_intersect);
}
// Simplify the bounds of each of the overlap regions.
for (auto &f : overlaps) {
simplify_box(f.second);
}
return overlaps;
}
// Return overlapping regions of producers ('prods') while computing a function
// stage along each of the dimensions.
vector<map<string, Box>>
DependenceAnalysis::overlap_regions(Function f, int stage_num,
const DimBounds &bounds,
const set<string> &prods,
bool only_regions_computed,
const Scope<Interval> *input_estimates) {
vector<map<string, Box>> conc_overlaps;
const vector<Dim> &dims = get_stage_dims(f, stage_num);
// Get the redundant regions along each dimension of f.
for (int d = 0; d < (int)dims.size() - 1; d++) {
map<string, Box> conc_reg = redundant_regions(f, stage_num, dims[d].var, bounds,
prods, only_regions_computed, input_estimates);
conc_overlaps.push_back(conc_reg);
}
return conc_overlaps;
}
// Return the regions of each function required for computing the
// outputs of the pipeline.
map<string, Box> get_pipeline_bounds(DependenceAnalysis &analysis,
const vector<Function> &outputs,
const Scope<Interval> *input_estimates) {
map<string, Box> pipeline_bounds;
// Find the regions required for each of the outputs and merge them
// to compute the full pipeline_bounds.
for (const auto &out : outputs) {
DimBounds pure_bounds;
Box out_box;
// Use the estimates on the output for determining the output bounds.
// If there are duplicates, use the most recent estimate.
const auto &estimates = out.schedule().estimates();
for (const auto &arg : out.args()) {
int i;
for (i = estimates.size() - 1; i >= 0; --i) {
const auto &est = estimates[i];
if ((est.var == arg) && est.min.defined() && est.extent.defined()) {
Interval in = Interval(est.min, simplify(est.min + est.extent - 1));
pure_bounds.emplace(arg, in);
out_box.push_back(in);
break;
}
}
internal_assert(i >= 0) << "Could not find estimate for " << arg << "\n";
}
set<string> prods;
for (const pair<string, Function> &fpair : analysis.env) {
prods.insert(fpair.first);
}
map<string, Box> regions = analysis.regions_required(out, pure_bounds, prods,
false, input_estimates);
// Add the output region to the pipeline bounds as well.
regions.emplace(out.name(), out_box);
merge_regions(pipeline_bounds, regions);
}
return pipeline_bounds;
}
struct AutoSchedule {
struct Stage {
string function;
size_t stage;
Stage(const string &f, size_t s) : function(f), stage(s) {}
bool operator==(const Stage &other) const {
return (function == other.function) && (stage == other.stage);
}
bool operator<(const Stage &other) const {
return (function < other.function) || ((function == other.function) && (stage < other.stage));
}
};
const map<string, Function> &env;
// Contain maps from function name to the topological order of the pipeline.
map<string, size_t> topological_order;
// Cache for storing all internal vars/rvars that have been declared during
// the course of schedule generation, to ensure that we don't introduce any
// duplicates in the string representation of the schedules.
map<string, VarOrRVar> internal_vars;
// Store the list of schedules applied to some function stages (most recent
// schedule is placed last in the list).
map<string, map<int, vector<string>>> func_schedules;
// Store the list of vars/rvars used in the schedule applied to some
// function stages.
map<string, map<int, set<string>>> used_vars;
AutoSchedule(const map<string, Function> &env, const vector<string> &order) : env(env) {
for (size_t i = 0; i < order.size(); ++i) {
topological_order.emplace(order[i], i);
}
// Allocate a slot in 'used_vars' for each function stages in the pipeline
for (const auto &iter : env) {
for (size_t i = 0; i < iter.second.updates().size() + 1; ++i) {
used_vars[iter.first][i];
}
}
}
// Given a function name, return a string representation of getting the
// function handle
string get_func_handle(const string &name) const {
size_t index = get_element(topological_order, name);
return "pipeline.get_func(" + std::to_string(index) + ")";
}
friend std::ostream& operator<<(std::ostream &stream, const AutoSchedule &sched) {
stream << "// Delete this line if not using Generator\n";
stream << "Pipeline pipeline = get_pipeline();\n\n";
for (const auto &iter : sched.internal_vars) {
if (iter.second.is_rvar) {
stream << "RVar ";
} else {
stream << "Var ";
}
stream << iter.first << "(\"" << iter.first << "\");\n";
}
stream << "\n";
// Declare all the functions + schedules
std::ostringstream func_ss;
std::ostringstream schedule_ss;
for (const auto &f : sched.func_schedules) {
const string &fname = get_sanitized_name(f.first);
func_ss << "Func " << fname << " = " << sched.get_func_handle(f.first) << ";\n";
schedule_ss << "{\n";
// Declare all the Vars and RVars that are actually used in the schedule
const Function &func = get_element(sched.env, f.first);
for (size_t i = 0; i < func.args().size(); ++i) {
if (sched.used_vars.at(func.name()).at(0).find(func.args()[i])
!= sched.used_vars.at(func.name()).at(0).end()) {
schedule_ss << " Var " << func.args()[i] << " = "
<< fname << ".args()[" << i << "];\n";
}
}
set<string> declared_rvars;
for (size_t i = 0; i < func.updates().size(); ++i) {
const vector<ReductionVariable> &rvars = func.updates()[i].schedule().rvars();
const set<string> &var_list = sched.used_vars.at(func.name()).at(i+1);
for (size_t j = 0; j < rvars.size(); ++j) {
if ((var_list.find(rvars[j].var) == var_list.end()) ||
(declared_rvars.find(rvars[j].var) != declared_rvars.end())) {
continue;
}
declared_rvars.insert(rvars[j].var);
schedule_ss << " RVar " << rvars[j].var << "("
<< fname << ".update(" << i << ").get_schedule().rvars()[" << j << "].var);\n";
}
}
for (const auto &s : f.second) {
internal_assert(!s.second.empty());
schedule_ss << " " << fname;
if (s.first > 0) {
schedule_ss << ".update(" << std::to_string(s.first - 1) << ")";
}
for (size_t i = 0; i < s.second.size(); ++i) {
schedule_ss << "\n ." << s.second[i];
}
schedule_ss << ";\n";
}
schedule_ss << "}\n";
}
stream << func_ss.str() << "\n";
stream << schedule_ss.str() << "\n";
return stream;
}
void push_schedule(const string &stage_name, size_t stage_num,
const string &sched, const set<string> &vars) {
vector<string> v = split_string(stage_name, ".");
internal_assert(!v.empty());
used_vars[v[0]][stage_num].insert(vars.begin(), vars.end());
// If the previous schedule applied is the same as this one,
// there is no need to re-apply the schedule
auto &schedules = func_schedules[v[0]][stage_num];
if (schedules.empty()) {
schedules.push_back(sched);
} else {
if (schedules[schedules.size()-1] != sched) {
schedules.push_back(sched);
}
}
}
};
// Implement the grouping algorithm and the cost model for making the grouping
// choices.
struct Partitioner {
// GroupingChoice encodes the grouping of the 'prod' function into the 'cons' stage.
struct GroupingChoice {
string prod;
FStage cons;
GroupingChoice(const string &prod, const FStage &cons) : prod(prod), cons(cons) {}
bool operator==(const GroupingChoice &other) const {
return (prod == other.prod) && (cons == other.cons);
}
bool operator<(const GroupingChoice &other) const {
return (prod < other.prod) || ((prod == other.prod) && (cons < other.cons));
}
friend std::ostream& operator<<(std::ostream &stream, const GroupingChoice &choice) {
stream << "Choice: " << choice.prod << " -> " << choice.cons << '\n';
return stream;
}
};
// A group is a sub-pipeline with a single output. Members of a group are
// either inlined into the consumer functions within the group or computed
// at tiles of the output, specified by 'tile_sizes'.
//
// TODO: The restriction of computing either at the inline or tile level
// makes the space of scheduling choices for a group very tractable.
// However, the restriction might miss good schedules which can only be
// realized by computing the members of the group at different levels of
// the group.
//
// There are two approaches to extend the space of schedules considered:
// 1) Recursive grouping: Treat the problem of determining the compute levels
// within a group as a smaller instance of the grouping problem with
// different parameters for the input, output sizes, and cache model.
//
// 2) Tightening: Always compute a function at the lowest level possible
// without introducing redundant work. This is a restricted form of recursive
// grouping which does not explore the trade-off between redundant work and
// locality.
//
// Either approach can be implemented as a post process for each group
// after the initial grouping process finishes. The cost model may
// already make sub-optimal higher level partitioning when it is not aware
// of the benefits of the post processing. However, it should strictly be
// an improvement over the initial grouping. As a first step, it is good
// to make it a post process.
//
// Incorporating the recursive grouping process into the cost model can be
// tricky and can potentially make the cost of analyzing a group
// prohibitive, as it requires solving smaller instances of the grouping
// problem for analyzing each configuration. On the other hand, tightening
// can be integrated into the cost model with out significantly increasing
// the time to analyze a grouping configuration.
//
// TODO: Add sliding window optimizations. For start, it may be enough to
// implement sliding window as a post-pass by moving the store level of all
// the members of the group to the outermost serial loop. This could possibly
// be incorporated in the cost model with some effort. Line-buffering
// presents additional challenges for this post-processing strategy though.
// A typical line-buffer would use terrible tile size for tiling, but its
// performance will improve significantly once sliding window is turned on.
//
// TODO: Register tiling is an important transformation especially for
// benchmarks with significant reuse of the data (like matrix multiply and
// convolutional layers). The mechanism for realizing register tiling is to
// completely unroll small tiles of the innermost kernels. Unrolling
// interacts with vectorization, storage layout, and depends on the outer
// level tiling.
struct Group {
// The output stage representing the group.
FStage output;
// Functions that belong to the group.
vector<FStage> members;
// Members of the group which are inlined.
set<string> inlined;
// Tile sizes along dimensions of the output function of the group.
map<string, Expr> tile_sizes;
Group(const FStage &output, const vector<FStage> &members)
: output(output), members(members) {}
friend std::ostream& operator<<(std::ostream &stream, const Group &g) {
stream << "Output FStage: " << g.output << '\n';
stream << "Members: " << '{';
for (size_t i = 0; i < g.members.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << g.members[i];
}
stream << "}" << '\n';
stream << "Inlined: " << '{';
for (auto iter = g.inlined.begin(); iter != g.inlined.end(); ++iter) {
if (std::distance(g.inlined.begin(), iter) > 0) {
stream << ", ";
}
stream << *iter;
}
stream << "}" << '\n';
stream << "Tile sizes: " << "{";
for (auto iter = g.tile_sizes.begin(); iter != g.tile_sizes.end(); ++iter) {
if (std::distance(g.tile_sizes.begin(), iter) > 0) {
stream << ", ";
}
stream << "(" << iter->first << ", " << iter->second << ")";
}
stream << "}" << '\n';
return stream;
}
};
// Result of the analysis of a group.
struct GroupAnalysis {
// Estimate of the arithmetic and memory cost for computing the group.
Cost cost;
// Estimate of the parallelism that can be exploited while computing
// the group.
Expr parallelism;
GroupAnalysis() : cost(Cost()) , parallelism(Expr()) {}
GroupAnalysis(const Cost &c, Expr p) : cost(c), parallelism(std::move(p)) {}
inline bool defined() const {
return cost.defined() && parallelism.defined();
}
void simplify() {
cost.simplify();
if (parallelism.defined()) {
parallelism = Internal::simplify(parallelism);
}
}
friend std::ostream& operator<<(std::ostream &stream, const GroupAnalysis &analysis) {
stream << "[arith cost:" << analysis.cost.arith << ", ";
stream << "memory cost:" << analysis.cost.memory << ", ";
stream << "parallelism:" << analysis.parallelism << "]\n";
return stream;
}
};
// Configuration of a group and the corresponding analysis. A group is the
// set of functions that are computed together in tiles and the group config
// specifies at what granularity they are computed together ('tile_sizes').
struct GroupConfig {
map<string, Expr> tile_sizes;
GroupAnalysis analysis;
GroupConfig(const map<string, Expr> &tile_sizes, const GroupAnalysis &analysis)
: tile_sizes(tile_sizes), analysis(analysis) {}
GroupConfig() : tile_sizes(map<string, Expr>()), analysis(GroupAnalysis()) {}
};
// Cache for storing the best configuration for the grouping choice. During
// the grouping process, the impact of grouping two groups together is only
// limited to the producers and consumers of the groups that are being grouped
// together. The best grouping choices for the rest of the pipeline need not be
// re-evaluated and caching them improves performance significantly.
map<GroupingChoice, GroupConfig> grouping_cache;
// Each group in the pipeline has a single output stage. A group is comprised
// of function stages that are computed together in tiles (stages of a function
// are always grouped together). 'groups' is the mapping from the output stage
// of the group to the group.
map<FStage, Group> groups;
// The child stages of each stage (i.e. stages that depend on or use the values
// computed by a particular stage) in the pipeline.
map<FStage, set<FStage>> children;
// Map from the output stage of the group to the analysis of the group. The mapping
// needs to be updated whenever the grouping changes.
map<FStage, GroupAnalysis> group_costs;
// Levels that are targeted by the grouping algorithm. In the 'Inline' mode, the grouping
// algorithm groups the functions by inlining the expression for the producer function
// into the consumer stage. In the 'FastMem' mode, the grouping is done at the level of
// tiles of the group output stage.
enum class Level {Inline, FastMem};
// Bounds of each function stage in the pipeline. These bounds are inferred from the
// estimates of the outputs and other functions in the pipeline.
const map<string, Box> &pipeline_bounds;
// Parameters of the machine model that is used for estimating the cost of each
// group in the pipeline.
const MachineParams &arch_params;
// Dependency analysis of the pipeline. This support queries on regions
// accessed and computed for producing some regions of some functions.
DependenceAnalysis &dep_analysis;
// The arithmetic and memory costs of evaluating the expressions which define
// each function in the pipeline.
RegionCosts &costs;
// Output functions of the pipeline.
const vector<Function> &outputs;
Partitioner(const map<string, Box> &_pipeline_bounds,
const MachineParams &_arch_params,
const vector<Function> &_outputs,
DependenceAnalysis &_dep_analysis,
RegionCosts &_costs);
void initialize_groups();
// Merge 'prod_group' into 'cons_group'. The output stage of 'cons_group'
// will be the output stage of the merged group.
Group merge_groups(const Group &prod_group, const Group &cons_group);
// Merge 'prods' in 'choice' into 'cons'. Set the tile size of the new group
// to the one specified by 'eval'. If 'level' is set to Inline, all members
// of 'prods' will be inlined in the new group.
void merge_groups(const GroupingChoice &choice, const GroupConfig &eval,
Partitioner::Level level);
// Given a grouping 'g', compute the estimated cost (arithmetic + memory) and
// parallelism that can be potentially exploited when computing that group.
GroupAnalysis analyze_group(const Group &g, bool show_analysis);
// For each group in the partition, return the regions of the producers
// need to be allocated to compute a tile of the group's output.
map<FStage, map<string, Box>> group_storage_bounds();
// For each group in the partition, return the regions of the producers
// required to compute a tile of the group's output.
map<FStage, map<FStage, DimBounds>> group_loop_bounds();
// Partition the pipeline by iteratively merging groups until a fixpoint is
// reached.
void group(Partitioner::Level level);
// Given a grouping choice, return a configuration for the group that gives
// the highest estimated benefits.
GroupConfig evaluate_choice(const GroupingChoice &group, Partitioner::Level level);
// Pick the best choice among all the grouping options currently available. Uses
// the cost model to estimate the benefit of each choice. This returns a vector of
// choice and configuration pairs which describe the best grouping choice.
vector<pair<GroupingChoice, GroupConfig>>
choose_candidate_grouping(const vector<pair<string, string>> &cands,
Partitioner::Level level);
// Return the bounds required to produce a function stage.
DimBounds get_bounds(const FStage &stg);
// Return the bounds required to produce a tile of a function stage.
DimBounds get_bounds_from_tile_sizes(const FStage &stg,
const map<string, Expr> &tile_sizes);
// Return the estimated size of the bounds.
map<string, Expr> bounds_to_estimates(const DimBounds &bounds);
// Given a function stage, return a vector of possible tile configurations for
// that function stage.
vector<map<string, Expr>> generate_tile_configs(const FStage &stg);
// Find the best tiling configuration for a group 'g' among a set of tile
// configurations. This returns a pair of configuration with the highest
// estimated benefit and the estimated benefit.
pair<map<string, Expr>, GroupAnalysis> find_best_tile_config(const Group &g);
// Estimate the benefit (arithmetic + memory) of 'new_grouping' over 'old_grouping'.
// Positive values indicates that 'new_grouping' may be preferrable over 'old_grouping'.
// When 'ensure_parallelism' is set to true, this will return an undefined cost
// if the estimated parallelism is smaller than the machine parameters.
// If 'no_redundant_work' is set, we only consider the arithmetic cost, i.e. if
// the arithmetic benefit is negative, we will treat it as no benefits and we
// should not perform the new grouping.
Expr estimate_benefit(const GroupAnalysis &old_grouping, const GroupAnalysis &new_grouping,
bool no_redundant_work, bool ensure_parallelism);
// Same as above; however, 'new_grouping' is a vector of function pairs that
// are to be grouped together.
Expr estimate_benefit(const vector<pair<GroupingChoice, GroupConfig>> &new_grouping,
bool no_redundant_work, bool ensure_parallelism);
// Return the total estimate on arithmetic and memory costs of computing all
// groups within the pipeline.
Cost get_pipeline_cost();
// Return the maximum access stride to allocation of 'func_acc' along any
// loop variable specified in 'vars'. Access expressions along each dimension
// of the allocation are specified by 'acc_exprs'. The dimension bounds of the
// allocation are specified by 'buffer_bounds'.
Expr find_max_access_stride(const Scope<> &vars, const string &func_acc,
const vector<Expr> &acc_exprs, const Box &buffer_bounds);
// Return the sum of access strides along each of the loop variables in
// a function stage. The bounds of all the allocations accessed are specified
// in 'allocation_bounds'. Return an empty map if it can't figure out any of
// the stride dimension.
map<string, Expr> analyze_spatial_locality(
const FStage &stg, const map<string, Box> &parent_bounds,
const set<string> &inlines = set<string>());
map<string, Expr> evaluate_reuse(const FStage &stg, const set<string> &prods);
// Generate and apply schedules for all functions within a pipeline by
// following their grouping structure.
//
// TODO: A mode where schedules are not applied to the functions might be
// interesting.
//
// TODO: The current form of the schedule returned is not very useful since it
// cannot be manipulated and introspected very easily. The problem is that all
// of the scheduling uses internal function and variable names which are not
// visible to the user. Additionally, functions like sum and maximum are not
// user visible. More thought needs to go into interaction between the user and
// auto scheduling.
void generate_cpu_schedule(const Target &t, AutoSchedule &sched);
// Same as \ref Partitioner::generate_cpu_schedule, but this generates and
// applies schedules for a group of function stages.
void generate_group_cpu_schedule(const Group &g, const Target &t,
const map<FStage, DimBounds> &group_loop_bounds,
const map<string, Box> &group_storage_bounds,
const set<string> &inlines,
AutoSchedule &sched);
// Split the dimension of stage 'f_handle' along 'v' into inner and outer
// dimensions. Modify 'estimates' according to the split and append the split
// schedule to 'sched'.
pair<VarOrRVar, VarOrRVar> split_dim(
const Group &g, Stage f_handle, int stage_num, Definition def,
bool is_group_output, VarOrRVar v, const Expr &factor, string in_suffix,
string out_suffix, map<string, Expr> &estimates, AutoSchedule &sched);
// Loop over the dimensions of function stage 'f_handle' starting from innermost
// and vectorize the first pure dimension encountered.
void vectorize_stage(
const Group &g, Stage f_handle, int stage_num, Definition def,
Function func, bool is_group_output, const Target &t, set<string> &rvars,
map<string, Expr> &estimates, AutoSchedule &sched);
// Reorder the dimensions to preserve spatial locality. This function
// checks the stride of each access. The dimensions of the loop are reordered
// such that the dimension with the smallest access stride is innermost.
// This takes the strides along each dimension as input.
void reorder_dims(Stage f_handle, int stage_num, Definition def,
map<string, Expr> strides, AutoSchedule &sched);
// Helper functions to display partition information of the pipeline.
void disp_pipeline_costs();
void disp_pipeline_bounds();
void disp_pipeline_graph();
void disp_grouping();
};
void Partitioner::disp_grouping() {
debug(0) << "\n=========" << '\n';
debug(0) << "Grouping:" << '\n';
debug(0) << "=========" << '\n';
for (const auto &g : groups) {
debug(0) << g.second << '\n';
}
debug(0) << "=========" << '\n';
}
void Partitioner::disp_pipeline_graph() {
debug(0) << "\n================" << '\n';
debug(0) << "Pipeline graph:" << '\n';
debug(0) << "================" << '\n';
for (const auto &f : children) {
debug(0) << f.first << ": {";
for (auto iter = f.second.begin(); iter != f.second.end(); ++iter) {
if (std::distance(f.second.begin(), iter) > 0) {
debug(0) << ", ";
}
debug(0) << *iter;
}
debug(0) << "}" << '\n';
}
debug(0) << "================" << '\n';
}
void Partitioner::disp_pipeline_bounds() {
debug(0) << "\n================" << '\n';
debug(0) << "Pipeline bounds:" << '\n';
debug(0) << "================" << '\n';
disp_regions(pipeline_bounds);
debug(0) << "===============" << '\n';
}
Cost Partitioner::get_pipeline_cost() {
internal_assert(!group_costs.empty());
Cost total_cost(0, 0);
for (const pair<FStage, Group> &g : groups) {
const GroupAnalysis &analysis = get_element(group_costs, g.first);
if (!analysis.cost.defined()) {
return Cost();
}
total_cost.arith += analysis.cost.arith;
total_cost.memory += analysis.cost.memory;
}
total_cost.simplify();
return total_cost;
}
void Partitioner::disp_pipeline_costs() {
internal_assert(!group_costs.empty());
Cost total_cost(0, 0);
debug(0) << "\n===============" << '\n';
debug(0) << "Pipeline costs:" << '\n';
debug(0) << "===============" << '\n';
debug(0) << "Group: (name) [arith cost, mem cost, parallelism]" << '\n';
for (const pair<FStage, Group> &g : groups) {
const GroupAnalysis &analysis = get_element(group_costs, g.first);
if (!total_cost.arith.defined()) {
continue;
} else if (!analysis.cost.arith.defined()) {
total_cost.arith = Expr();
} else {
total_cost.arith += analysis.cost.arith;
}
if (!total_cost.memory.defined()) {
continue;
} else if (!analysis.cost.memory.defined()) {
total_cost.memory = Expr();
} else {
total_cost.memory += analysis.cost.memory;
}
debug(0) << "Group: " << g.first << " [";
debug(0) << analysis.cost.arith << ", " << analysis.cost.memory
<< ", " << analysis.parallelism << "]\n";
}
total_cost.simplify();
debug(0) << "Total arithmetic cost: " << total_cost.arith << '\n';
debug(0) << "Total memory cost: " << total_cost.memory << '\n';
debug(0) << "===============" << '\n';
}
// Construct a partitioner and build the pipeline graph on which the grouping
// algorithm operates.
Partitioner::Partitioner(const map<string, Box> &_pipeline_bounds,
const MachineParams &_arch_params,
const vector<Function> &_outputs,
DependenceAnalysis &_dep_analysis,
RegionCosts &_costs)
: pipeline_bounds(_pipeline_bounds), arch_params(_arch_params),
dep_analysis(_dep_analysis), costs(_costs), outputs(_outputs) {
// Place each stage of a function in its own group. Each stage is
// a node in the pipeline graph.
for (const auto &f : dep_analysis.env) {
if (!pipeline_bounds.count(f.first)) {
// If a function does not have a pipeline bound (i.e. it can be
// statically proven that no one ever uses it), we should not
// consider it during the grouping.
debug(5) << "Creating partitioner: ignore function \"" << f.first
<< "\" since it has empty pipeline bounds\n";
continue;
}
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
FStage stg(f.second, s);
Group g(stg, {stg});
groups.insert(make_pair(stg, g));
}
}
// Find the consumers of each function and use it to populate the children map.
for (const auto &f : dep_analysis.env) {
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
set<string> parents = get_parents(f.second, s);
for (const string &c : parents) {
// Filter out the calls to pipeline inputs. 'env' only contains
// the functions computed and not the inputs.
auto iter = dep_analysis.env.find(c);
if ((c != f.first) && (iter != dep_analysis.env.end())) {
// Consumer depends only on the last stage of a producer
// with multiple stages.
const Function &prod_func = iter->second;
int final_stage = prod_func.updates().size();
FStage prod_stage(prod_func, final_stage);
FStage cons_stage(f.second, s);
children[prod_stage].insert(cons_stage);
}
}
if (s > 0) {
// Update the children map to reflect the dependencies between
// different stages of the same function.
FStage prod_stage(f.second, s - 1);
FStage cons_stage(f.second, s);
children[prod_stage].insert(cons_stage);
}
}
}
}
void Partitioner::initialize_groups() {
for (pair<const FStage, Group> &g : groups) {
pair<map<string, Expr>, GroupAnalysis> best = find_best_tile_config(g.second);
g.second.tile_sizes = best.first;
group_costs.emplace(g.second.output, best.second);
}
grouping_cache.clear();
}
map<string, Expr> Partitioner::evaluate_reuse(const FStage &stg,
const set<string> &prods) {
map<string, Expr> reuse;
Function f = stg.func;
// TODO: Check if tile size of 1 in each dimension gives a reasonable
// answer or reuse should be evaluated at a much larger granularity or
// symbolically. Using a symbolic version might be better if the objective
// is to prove the dimension has no reuse. The only downside with the
// symbolic method is that it is totally at the mercy of the simplifier.
// Another option is sampling or using a larger granularity.
map<string, Expr> tile_sizes;
const vector<Dim> &dims = get_stage_dims(stg.func, stg.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
tile_sizes[dims[d].var] = 1;
}
DimBounds bounds = get_bounds_from_tile_sizes(stg, tile_sizes);
vector<map<string, Box>> reuse_regions =
dep_analysis.overlap_regions(stg.func, stg.stage_num, bounds, prods,
false, &costs.input_estimates);
for (int d = 0; d < (int)dims.size() - 1; d++) {
Expr total_reuse = make_zero(Int(64));
if (debug::debug_level() >= 3) {
disp_regions(reuse_regions[d]);
}
for (const auto ® : reuse_regions[d]) {
Expr size = box_size(reg.second);
if (!size.defined()) {
total_reuse = Expr();
break;
} else {
total_reuse += size;
}
}
reuse.emplace(dims[d].var, simplify(total_reuse));
}
return reuse;
}
vector<pair<Partitioner::GroupingChoice, Partitioner::GroupConfig>>
Partitioner::choose_candidate_grouping(const vector<pair<string, string>> &cands,
Partitioner::Level level) {
vector<pair<GroupingChoice, GroupConfig>> best_grouping;
Expr best_benefit = make_zero(Int(64));
for (const auto &p : cands) {
// Compute the aggregate benefit of inlining into all the children.
vector<pair<GroupingChoice, GroupConfig>> grouping;
const Function &prod_f = get_element(dep_analysis.env, p.first);
int final_stage = prod_f.updates().size();
FStage prod(prod_f, final_stage);
for (const FStage &c : get_element(children, prod)) {
GroupConfig best_config;
GroupingChoice cand_choice(prod_f.name(), c);
// Check if the candidate has been evaluated for grouping before
const auto &iter = grouping_cache.find(cand_choice);
if (iter != grouping_cache.end()) {
best_config = iter->second;
} else {
best_config = evaluate_choice(cand_choice, level);
// Cache the result of the evaluation for the pair
grouping_cache.emplace(cand_choice, best_config);
}
grouping.push_back(make_pair(cand_choice, best_config));
}
bool no_redundant_work = false;
Expr overall_benefit = estimate_benefit(grouping, no_redundant_work, true);
debug(3) << "Candidate grouping:\n";
for (const auto &g : grouping) {
debug(3) << " " << g.first;
}
debug(3) << "Candidate benefit: " << overall_benefit << '\n';
// TODO: The grouping process can be non-deterministic when the costs
// of two choices are equal
if (overall_benefit.defined() && can_prove(best_benefit < overall_benefit)) {
best_grouping = grouping;
best_benefit = overall_benefit;
}
}
debug(3) << "\nBest grouping:\n";
for (const auto &g : best_grouping) {
debug(3) << " " << g.first;
}
if (best_grouping.size() > 0) {
debug(3) << "Best benefit: " << best_benefit << '\n';
}
return best_grouping;
}
inline bool operator==(const map<string, Expr> &m1, const map<string, Expr> &m2) {
if (m1.size() != m2.size()) {
return false;
}
for (const auto &it1 : m1) {
const auto &it2 = m2.find(it1.first);
if (it2 == m2.end()) {
return false;
} else if (!equal(it1.second, it2->second)) {
return false;
}
}
return true;
}
vector<map<string, Expr>> Partitioner::generate_tile_configs(const FStage &stg) {
// TODO: This is a wart due to the cost model not taking vectorization
// and pre-fetching into account. Ensuring the innermost dimension has
// at least size of 64 gives enough values for vectorization and can help
// with prefetching. This also interacts with the number of parallel tasks
// that are generated.
int min_inner_dim_size = 64;
const vector<Dim> &dims = get_stage_dims(stg.func, stg.stage_num);
// Get the dimensions that are going to be tiled in this stage.
// Skipping rvars for now.
vector<string> tile_vars;
for (int d = 0; d < (int)dims.size() - 1; d++) {
if (!dims[d].is_rvar()) {
tile_vars.push_back(dims[d].var);
}
}
vector<int> size_variants = {1, 4, 8, 16, 32, 64, 128, 256};
vector<map<string, Expr>> tile_configs;
// For all the tile configurations generated, we force the innermost dimension
// to be at least of size 64 to ensure enough values for vectorization.
// Skewed tile configurations
for (size_t i = 0; i < tile_vars.size(); i++) {
for (const auto &dim_size : size_variants) {
map<string, Expr> tiling;
tiling.emplace(tile_vars[i],
(i == 0) ? std::max(dim_size, min_inner_dim_size): dim_size);
for (size_t j = 0; j < tile_vars.size(); j++) {
if (j < i) {
tiling.emplace(tile_vars[j], size_variants[size_variants.size() - 1]);
} else if (j > i) {
tiling.emplace(tile_vars[j], size_variants[0]);
}
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
}
// Almost square tile configurations
for (const auto &dim_size : size_variants) {
map<string, Expr> tiling;
for (size_t j = 0; j < tile_vars.size(); j++) {
tiling.emplace(tile_vars[j],
(j == 0) ? std::max(dim_size, min_inner_dim_size): dim_size);
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
// Reorder tile configurations
for (int i = 0; i < (1 << (tile_vars.size())); i++) {
map<string, Expr> tiling;
for (size_t j = 0; j < tile_vars.size(); j++) {
if (((i >> (j)) & 1) == 1) {
if (j == 0) {
tiling.emplace(tile_vars[j], min_inner_dim_size);
} else {
tiling.emplace(tile_vars[j], 1);
}
}
}
if (!tiling.empty()) {
bool is_duplicate =
std::find_if(tile_configs.begin(), tile_configs.end(),
[&tiling](const map<string, Expr> &m) { return (tiling == m);})
!= tile_configs.end();
if (!is_duplicate) {
tile_configs.push_back(tiling);
}
}
}
return tile_configs;
}
pair<map<string, Expr>, Partitioner::GroupAnalysis>
Partitioner::find_best_tile_config(const Group &g) {
// Initialize to no tiling
map<string, Expr> no_tile_config;
Group no_tile = g;
no_tile.tile_sizes = no_tile_config;
bool show_analysis = false;
GroupAnalysis no_tile_analysis = analyze_group(no_tile, show_analysis);
GroupAnalysis best_analysis = no_tile_analysis;
map<string, Expr> best_config = no_tile_config;
if (!best_analysis.cost.defined()) {
return make_pair(best_config, best_analysis);
}
// Generate tiling configurations
vector<map<string, Expr>> configs = generate_tile_configs(g.output);
Group best_group = g;
for (const auto &config : configs) {
Group new_group = g;
new_group.tile_sizes = config;
GroupAnalysis new_analysis = analyze_group(new_group, show_analysis);
bool no_redundant_work = false;
Expr benefit = estimate_benefit(best_analysis, new_analysis,
no_redundant_work, true);
if (show_analysis) {
debug(0) << "Benefit relative to not tiling:" << benefit << '\n';
debug(0) << "Best analysis:" << new_analysis;
debug(0) << "No tile analysis:" << no_tile_analysis;
debug(0)
<< "arith cost:" << cast<float>(new_analysis.cost.arith / no_tile_analysis.cost.arith)
<< ", mem cost:" << cast<float>(new_analysis.cost.memory / no_tile_analysis.cost.memory) << '\n';
}
if (benefit.defined() && can_prove(benefit > 0)) {
best_config = config;
best_analysis = new_analysis;
best_group = new_group;
}
}
return make_pair(best_config, best_analysis);
}
void Partitioner::group(Partitioner::Level level) {
bool fixpoint = false;
while (!fixpoint) {
Cost pre_merge = get_pipeline_cost();
fixpoint = true;
vector<pair<string, string>> cand;
for (const pair<FStage, Group> &g : groups) {
bool is_output = false;
for (const Function &f : outputs) {
if (g.first.func.name() == f.name()) {
is_output = true;
break;
}
}
// All stages of a function are computed at a single location.
// The last stage of the function represents the candidate choice
// of grouping the function into a consumer.
const Function &prod_f = get_element(dep_analysis.env, g.first.func.name());
bool is_final_stage = (g.first.stage_num == prod_f.updates().size());
if (is_output || !is_final_stage) {
continue;
}
const auto &iter = children.find(g.first);
if (iter != children.end()) {
// All the stages belonging to a function are considered to be a
// single child.
set<string> child_groups;
for (const FStage &s : iter->second) {
child_groups.insert(s.func.name());
}
int num_children = child_groups.size();
// Only groups with a single child are considered for grouping
// when grouping for computing in tiles.
// TODO: The current scheduling model does not allow functions
// to be computed at different points.
if ((num_children == 1) && (level == Partitioner::Level::FastMem)) {
const string &prod_name = prod_f.name();
const string &cons_name = (*child_groups.begin());
cand.push_back(make_pair(prod_name, cons_name));
} else if((level == Partitioner::Level::Inline) && prod_f.is_pure()) {
const string &prod_name = prod_f.name();
cand.push_back(make_pair(prod_name, ""));
}
}
}
debug(3) << "\n============================" << '\n';
debug(3) << "Current grouping candidates:" << '\n';
debug(3) << "============================" << '\n';
for (size_t i = 0; i < cand.size(); ++i) {
debug(3) << "{" << cand[i].first << ", " << cand[i].second << "}" << '\n';
}
vector<pair<GroupingChoice, GroupConfig>> best = choose_candidate_grouping(cand, level);
if (best.empty()) {
continue;
} else {
fixpoint = false;
}
// The following code makes the assumption that all the stages of a function
// will be in the same group. 'choose_candidate_grouping' ensures that the
// grouping choice being returned adheres to this constraint.
const string &prod = best[0].first.prod;
const Function &prod_f = get_element(dep_analysis.env, prod);
size_t num_stages = prod_f.updates().size() + 1;
FStage final_stage(prod_f, num_stages - 1);
set<FStage> prod_group_children = get_element(children, final_stage);
// Invalidate entries of the grouping cache
set<GroupingChoice> invalid_keys;
for (const auto &c : prod_group_children) {
for (const auto &entry : grouping_cache) {
if ((entry.first.prod == c.func.name()) || (entry.first.cons == c)) {
invalid_keys.insert(entry.first);
}
}
}
for (const auto &key : invalid_keys) {
grouping_cache.erase(key);
}
for (const auto &group : best) {
internal_assert(group.first.prod == prod);
merge_groups(group.first, group.second, level);
}
for (size_t s = 0; s < num_stages; s++) {
FStage prod_group(prod_f, s);
groups.erase(prod_group);
group_costs.erase(prod_group);
// Update the children mapping
children.erase(prod_group);
for (auto &f : children) {
set<FStage> &cons = f.second;
auto iter = cons.find(prod_group);
if (iter != cons.end()) {
cons.erase(iter);
// For a function with multiple stages, all the stages will
// be in the same group and the consumers of the function
// only depend on the last stage. Therefore, when the
// producer group has multiple stages, parents of the
// producers should point to the consumers of the last
// stage of the producer.
cons.insert(prod_group_children.begin(), prod_group_children.end());
}
}
}
Cost post_merge = get_pipeline_cost();
if (debug::debug_level() >= 3) {
disp_pipeline_costs();
}
}
}
DimBounds Partitioner::get_bounds(const FStage &s) {
DimBounds bounds;
const vector<string> &args = s.func.args();
for (size_t d = 0; d < args.size(); d++) {
bounds[args[d]] = get_element(pipeline_bounds, s.func.name())[d];
}
return get_stage_bounds(s.func, s.stage_num, bounds);
}
DimBounds Partitioner::get_bounds_from_tile_sizes(const FStage &s,
const map<string, Expr> &tile_sizes) {
map<string, Interval> bounds;
const map<string, Interval> &def_bounds = get_bounds(s);
const vector<Dim> &dims = get_stage_dims(s.func, s.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var = dims[d].var;
const Interval &bound = get_element(def_bounds, var);
const auto &iter = tile_sizes.find(var);
if (iter != tile_sizes.end()) {
const Expr &size = iter->second;
// Check if the bounds allow for tiling with the given tile size,
// i.e. ensure at least 2 tiles
Expr extent = get_extent(bound);
internal_assert(extent.defined());
if (can_prove(extent >= 2 * size)) {
// TODO: Maybe shift this to the center of the pipeline bound
bounds[var] = Interval(0, simplify(size - 1));
} else {
// If the dimension is too small, do not tile it and set the
// extent of the bounds to that of the dimension estimate
bounds[var] = bound;
}
} else {
bounds[var] = bound;
}
}
return bounds;
}
Partitioner::GroupAnalysis Partitioner::analyze_group(const Group &g, bool show_analysis) {
set<string> group_inputs;
set<string> group_members;
for (const auto &stg : g.members) {
group_members.insert(stg.func.name());
set<string> parents = get_parents(stg.func, stg.stage_num);
for (const auto &c : parents) {
bool is_member = false;
for (const auto &m : g.members) {
if (m.func.name() == c) {
is_member = true;
break;
}
}
if (!is_member) {
group_inputs.insert(c);
}
}
}
// Count the number of tiles
Expr estimate_tiles = make_one(Int(64));
Expr parallelism = make_one(Int(64));
if (!g.output.func.has_extern_definition()) {
// Get the definition corresponding to the group output
Definition def = get_stage_definition(g.output.func, g.output.stage_num);
const vector<Dim> &dims = def.schedule().dims();
DimBounds stg_bounds = get_bounds(g.output);
for (int d = 0; d < (int)dims.size() - 1; d++) {
const string &var = dims[d].var;
const auto &iter = g.tile_sizes.find(var);
if (iter != g.tile_sizes.end()) {
const Expr &size = iter->second;
Expr extent = get_extent(get_element(stg_bounds, var));
if (!extent.defined()) {
return GroupAnalysis();
}
Expr dim_tiles = simplify((extent + size - 1) / size);
estimate_tiles *= dim_tiles;
// Since all Vars are inherently parallelizable by construct, we
// only need to take RVars into account for the analysis.
if (can_parallelize_rvar(var, g.output.func.name(), def)) {
parallelism *= dim_tiles;
}
}
}
}
// Get the regions of the pipeline required to compute a tile of the group
DimBounds tile_bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
map<string, Box> alloc_regions = dep_analysis.regions_required(
g.output.func, g.output.stage_num, tile_bounds, group_members, false, &costs.input_estimates);
map<string, Box> compute_regions = dep_analysis.regions_required(
g.output.func, g.output.stage_num, tile_bounds, group_members, true, &costs.input_estimates);
map<string, Box> group_reg, prod_reg, input_reg;
// Separating into regions that computed within the group and regions that
// are input to the group
for (const auto ® : compute_regions) {
if ((group_members.find(reg.first) != group_members.end()) &&
(reg.first != g.output.func.name())) {
group_reg.emplace(reg.first, reg.second);
} else if (group_inputs.find(reg.first) != group_inputs.end()) {
if (dep_analysis.env.find(reg.first) != dep_analysis.env.end()) {
prod_reg.emplace(reg.first, reg.second);
} else {
input_reg.emplace(reg.first, reg.second);
}
}
}
// Aggregate costs for intermediate functions in a tile and the
// tile output
Cost tile_cost = costs.region_cost(group_reg, g.inlined);
if (!tile_cost.defined()) {
return GroupAnalysis();
}
Cost out_cost = costs.stage_region_cost(g.output.func.name(),
g.output.stage_num,
tile_bounds, g.inlined);
if (!out_cost.defined()) {
return GroupAnalysis();
}
for (const auto ® : alloc_regions) {
if (!box_size(reg.second).defined()) {
return GroupAnalysis();
}
}
Cost group_cost(simplify(tile_cost.arith + out_cost.arith),
simplify(tile_cost.memory + out_cost.memory));
// Detailed load costs for all the group intermediates
map<string, Expr> group_load_costs =
costs.detailed_load_costs(group_reg, g.inlined);
map<string, Expr> out_load_costs =
costs.stage_detailed_load_costs(g.output.func.name(),
g.output.stage_num,
tile_bounds, g.inlined);
combine_load_costs(group_load_costs, out_load_costs);
Box out_tile_extent;
if (g.output.stage_num == 0) {
const vector<string> &args = g.output.func.args();
for (size_t d = 0; d < args.size(); d++) {
const auto &iter = tile_bounds.find(args[d]);
if (iter != tile_bounds.end()) {
out_tile_extent.push_back(iter->second);
} else {
out_tile_extent.push_back(Interval());
}
}
}
Cost per_tile_cost(group_cost.arith, make_zero(Int(64)));
// This is the old cost model; keeping it here for reference, for now.
/*
if (tile_inter_size > arch_params.l1_size) {
// Conservative estimate of accesses to memory
//per_tile_mem_cost = tile_inter_size;
// Aggressive estimate of accesses to memory
per_tile_mem_cost = tile_cost.second;
} else {
// The tile_input_size captures the region of the input
// required to compute the tile. However, all of it many not be
// accessed during the computation of the tile when the access
// is sparse. A better estimate is given by the smaller of
// the number of memory accesses and the region size
per_tile_mem_cost = std::min(tile_input_size + tile_output_size,
tile_cost.second);
}*/
// TODO: Use smooth step curve from Jon to better model cache behavior,
// where each step corresponds to different cache level.
//
// The current cost model drops off linearly. Larger memory footprint is
// penalized more than smaller memory footprint (since smaller one can fit
// more in the cache). The cost is clamped at 'balance', which is roughly at
// memory footprint equal to or larger than the last level cache size.
// If 'model_reuse' is set, the cost model should take into account memory
// reuse within the tile, e.g. matrix multiply reuses inputs multiple times.
// TODO: Implement a better reuse model.
bool model_reuse = false;
// Linear dropoff
Expr load_slope = cast<float>(arch_params.balance) / arch_params.last_level_cache_size;
for (const auto &f_load : group_load_costs) {
internal_assert(g.inlined.find(f_load.first) == g.inlined.end())
<< "Intermediates of inlined pure fuction \"" << f_load.first
<< "\" should not have been in the group_load_costs\n";
const auto &alloc_reg = get_element(alloc_regions, f_load.first);
Expr footprint;
bool is_group_member = (group_members.find(f_load.first) != group_members.end());
bool is_output = (f_load.first == g.output.func.name());
// We use allocated region as conservative estimate of the footprint since
// the loads could be from any random locations of the allocated regions.
if (!is_output && is_group_member) {
footprint = costs.region_size(f_load.first, alloc_reg);
} else {
Expr initial_footprint;
const auto &f_load_pipeline_bounds = get_element(pipeline_bounds, f_load.first);
bool is_function = (dep_analysis.env.find(f_load.first) != dep_analysis.env.end());
if (!is_function) { // It is a load to some input buffer
// Initial loads
initial_footprint = costs.input_region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.input_region_size(f_load.first, alloc_reg);
} else if (is_output) { // Load to the output function of the group
internal_assert(is_group_member)
<< "Output " << f_load.first << " should have been a group member\n";
// Initial loads
initial_footprint = costs.region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.region_size(f_load.first, out_tile_extent);
} else { // Load to some non-member function (i.e. function from other groups)
// Initial loads
initial_footprint = costs.region_size(f_load.first, f_load_pipeline_bounds);
// Subsequent loads
footprint = costs.region_size(f_load.first, alloc_reg);
}
if (model_reuse) {
Expr initial_factor =
cast<int64_t>(min(1 + initial_footprint * load_slope, arch_params.balance));
per_tile_cost.memory += initial_factor * footprint;
} else {
footprint = initial_footprint;
}
if (!footprint.defined()) {
return GroupAnalysis();
}
}
Expr cost_factor = cast<int64_t>(min(1 + footprint * load_slope, arch_params.balance));
per_tile_cost.memory += cost_factor * f_load.second;
}
if (show_analysis) {
debug(0) << "\nDetailed loads:\n";
for (const auto &f_load : group_load_costs) {
debug(0) << "(" << f_load.first << "," << f_load.second << ")";
}
debug(0) << '\n';
debug(0) << "\nPer tile memory cost:" << per_tile_cost.memory << '\n';
debug(0) << "Per tile arith cost:" << per_tile_cost.arith << '\n';
}
GroupAnalysis g_analysis(
Cost(per_tile_cost.arith * estimate_tiles, per_tile_cost.memory * estimate_tiles),
parallelism);
g_analysis.simplify();
return g_analysis;
}
Partitioner::Group Partitioner::merge_groups(const Group &prod_group,
const Group &cons_group) {
vector<FStage> group_members;
for (const auto &s : prod_group.members) {
group_members.push_back(s);
}
for (const auto &s : cons_group.members) {
group_members.push_back(s);
}
Group group(cons_group.output, group_members);
for (const auto &f : prod_group.inlined) {
group.inlined.insert(f);
}
for (const auto &f : cons_group.inlined) {
group.inlined.insert(f);
}
return group;
}
void Partitioner::merge_groups(const GroupingChoice &choice, const GroupConfig &eval,
Partitioner::Level level) {
const Function &prod_f = get_element(dep_analysis.env, choice.prod);
size_t num_stages = prod_f.updates().size() + 1;
const FStage &child = choice.cons;
Group &child_group = get_element(groups, child);
for (size_t s = 0; s < num_stages; s++) {
FStage cand(prod_f, s);
Group &cand_group = get_element(groups, cand);
child_group.members.insert(child_group.members.end(),
cand_group.members.begin(),
cand_group.members.end());
if (level == Partitioner::Level::Inline) {
for (const auto &stg : cand_group.members) {
child_group.inlined.insert(stg.func.name());
}
} else {
for (const auto &in : cand_group.inlined) {
child_group.inlined.insert(in);
}
}
}
child_group.tile_sizes = eval.tile_sizes;
// Update group costs.
// We could just reuse the analysis from 'eval' since it was computed
// by assuming the merge had happened.
group_costs[child] = eval.analysis;
}
Partitioner::GroupConfig Partitioner::evaluate_choice(const GroupingChoice &choice,
Partitioner::Level level) {
// Create a group that reflects the grouping choice and evaluate the cost
// of the group.
const Function &prod_f = get_element(dep_analysis.env, choice.prod);
int num_prod_stages = prod_f.updates().size() + 1;
vector<Group> prod_groups;
for (int s = 0; s < num_prod_stages; s++) {
FStage prod_s(prod_f, s);
prod_groups.push_back(get_element(groups, prod_s));
}
Group cons = get_element(groups, choice.cons);
Group group = cons;
for (const auto &prod_g : prod_groups) {
group = merge_groups(prod_g, group);
}
GroupAnalysis group_analysis;
map<string, Expr> best_tile_config;
if (level == Partitioner::Level::Inline) {
// Set the tile sizes to one along all dimensions of the consumer group
map<string, Expr> tile_sizes;
const Function &cons_f = cons.output.func;
const vector<Dim> &dims = get_stage_dims(cons_f, cons.output.stage_num);
for (int d = 0; d < (int)dims.size() - 1; d++) {
tile_sizes[dims[d].var] = 1;
}
group.tile_sizes = tile_sizes;
for (const auto &prod_g : prod_groups) {
for (const FStage &s : prod_g.members) {
group.inlined.insert(s.func.name());
}
}
for (const string &f : cons.inlined) {
group.inlined.insert(f);
}
group_analysis = analyze_group(group, false);
best_tile_config = tile_sizes;
} else {
pair<map<string, Expr>, GroupAnalysis> config = find_best_tile_config(group);
best_tile_config = config.first;
group_analysis = config.second;
}
return GroupConfig(best_tile_config, group_analysis);
}
Expr Partitioner::estimate_benefit(const GroupAnalysis &old_grouping,
const GroupAnalysis &new_grouping,
bool no_redundant_work,
bool ensure_parallelism) {
// TODO: Instead of having a hard parallelism constraint, it may be better
// to consider other metric, such as arith_cost/parallelism
if (ensure_parallelism &&
(!new_grouping.parallelism.defined() ||
!can_prove(new_grouping.parallelism >= arch_params.parallelism))) {
return Expr();
}
if (!old_grouping.cost.defined() || !new_grouping.cost.defined()) {
return Expr();
}
Expr arith_benefit = old_grouping.cost.arith - new_grouping.cost.arith;
if (no_redundant_work && !can_prove(arith_benefit >= 0)) {
return Expr();
}
Expr mem_benefit = old_grouping.cost.memory - new_grouping.cost.memory;
return simplify(mem_benefit + arith_benefit);
}
Expr Partitioner::estimate_benefit(
const vector<pair<GroupingChoice, GroupConfig>> &new_grouping,
bool no_redundant_work, bool ensure_parallelism) {
set<FStage> old_groups;
GroupAnalysis new_group_analysis(Cost(0, 0), Int(64).max());
for (const auto &g : new_grouping) {
const Function &prod_f = get_element(dep_analysis.env, g.first.prod);
int num_prod_stages = prod_f.updates().size() + 1;
for (int s = 0; s < num_prod_stages; s++) {
FStage prod_s(prod_f, s);
old_groups.insert(prod_s);
}
old_groups.insert(g.first.cons);
GroupAnalysis analysisg = g.second.analysis;
if (analysisg.defined()) {
new_group_analysis.cost.arith += analysisg.cost.arith;
new_group_analysis.cost.memory += analysisg.cost.memory;
new_group_analysis.parallelism = min(new_group_analysis.parallelism,
analysisg.parallelism);
} else {
new_group_analysis.cost = Cost();
new_group_analysis.parallelism = Expr();
break;
}
}
new_group_analysis.simplify();
GroupAnalysis old_group_analysis(Cost(0, 0), Int(64).max());
for (const auto &g : old_groups) {
const auto &iter = group_costs.find(g);
internal_assert(iter != group_costs.end());
GroupAnalysis analysisg = iter->second;
if (analysisg.defined()) {
old_group_analysis.cost.arith += analysisg.cost.arith;
old_group_analysis.cost.memory += analysisg.cost.memory;
old_group_analysis.parallelism = min(old_group_analysis.parallelism,
analysisg.parallelism);
} else {
old_group_analysis.cost = Cost();
old_group_analysis.parallelism = Expr();
break;
}
}
old_group_analysis.simplify();
return estimate_benefit(old_group_analysis, new_group_analysis,
no_redundant_work, ensure_parallelism);
}
map<string, Expr> Partitioner::bounds_to_estimates(const DimBounds &bounds) {
map<string, Expr> estimates;
for (const auto &bound : bounds) {
estimates.emplace(bound.first, get_extent(bound.second));
}
return estimates;
}
map<FStage, map<string, Box>> Partitioner::group_storage_bounds() {
map<FStage, map<string, Box>> group_storage_bounds;
for (const pair<const FStage, Group> &gpair : groups) {
const Group &g = gpair.second;
DimBounds bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
set<string> prods;
for (const FStage &s : g.members) {
prods.insert(s.func.name());
}
map<string, Box> reg_alloc =
dep_analysis.regions_required(g.output.func, g.output.stage_num,
bounds, prods, false, &costs.input_estimates);
map<string, Box> group_alloc;
for (const FStage &s : g.members) {
const auto &iter = reg_alloc.find(s.func.name());
if ((iter != reg_alloc.end()) && (s.func.name() != g.output.func.name())) {
group_alloc[s.func.name()] = iter->second;
}
}
group_storage_bounds[gpair.first] = group_alloc;
}
return group_storage_bounds;
}
map<FStage, map<FStage, DimBounds>> Partitioner::group_loop_bounds() {
map<FStage, map<FStage, DimBounds>> group_bounds;
for (const pair<const FStage, Group> &gpair : groups) {
Group g = gpair.second;
map<FStage, DimBounds> mem_bounds;
DimBounds bounds = get_bounds_from_tile_sizes(g.output, g.tile_sizes);
set<string> prods;
for (const FStage &s : g.members) {
prods.insert(s.func.name());
}
map<string, Box> reg_computed =
dep_analysis.regions_required(g.output.func, g.output.stage_num,
bounds, prods, true, &costs.input_estimates);
for (const FStage &s : g.members) {
const auto &iter = reg_computed.find(s.func.name());
if (iter != reg_computed.end()) {
map<string, Expr> tile_sizes;
const vector<string> &args = s.func.args();
for (size_t arg = 0; arg < args.size(); arg++) {
tile_sizes[args[arg]] = get_extent(iter->second[arg]);
}
mem_bounds[s] = get_bounds_from_tile_sizes(s, tile_sizes);
}
}
group_bounds[gpair.first] = mem_bounds;
}
return group_bounds;
}
// We need to get the base name of the dimension for scheduling (i.e. it
// can't have any dots). For example, in split case, if "x" is the starting
// dimension name, after split(x, x0, xi, ...), we will end up with something
// like "x.x0" and "x.xi". If we want to later schedule "x.x0", we need to
// pass "x0" instead of "x.x0".
string get_base_name(string name) {
size_t dot_pos = name.rfind('.');
if (dot_pos != string::npos) {
return name.substr(dot_pos + 1);
}
return name;
}
// Return true if any of the values or args in 'def' refers to any of
// the inputs or outputs, with access function which depends on 'var'.
bool access_inputs_or_outputs(Definition def, VarOrRVar var,
const map<string, Type> &inputs,
const vector<Function> &outputs) {
FindAllCalls find;
def.accept(&find);
for (size_t i = 0; i < find.call_args.size(); ++i) {
const string &func = find.call_args[i].first;
const vector<Expr> &args = find.call_args[i].second;
if (inputs.find(func) == inputs.end()) {
// Check if 'func' is an output
bool is_output =
std::find_if(outputs.begin(), outputs.end(),
[&func](const Function &f) { return (f.name() == func);})
!= outputs.end();
if (!is_output) {
// 'func' is neither an input or an output
continue;
}
}
// Check if any of the accesses to 'func' depends on 'var'
for (const auto &arg : args) {
if (expr_uses_var(arg, var.name())) {
return true;
}
}
}
return false;
}
pair<VarOrRVar, VarOrRVar> Partitioner::split_dim(
const Group &g, Stage f_handle, int stage_num, Definition def,
bool is_group_output, VarOrRVar v, const Expr &factor, string in_suffix,
string out_suffix, map<string, Expr> &estimates, AutoSchedule &sched) {
// Create new variables for the split dimensions
string arg_name = v.name();
string inner_name = arg_name + in_suffix;
string outer_name = arg_name + out_suffix;
VarOrRVar inner(inner_name, v.is_rvar), outer(outer_name, v.is_rvar);
{
const auto &iter = sched.internal_vars.find(inner.name());
if (iter == sched.internal_vars.end()) {
sched.internal_vars.emplace(inner.name(), inner);
} else {
internal_assert(iter->second.is_rvar == inner.is_rvar);
}
}
{
const auto &iter = sched.internal_vars.find(outer.name());
if (iter == sched.internal_vars.end()) {
sched.internal_vars.emplace(outer.name(), outer);
} else {
internal_assert(iter->second.is_rvar == outer.is_rvar);
}
}
// The default tail strategy is good enough for most use cases (see docs on
// TailStrategy::Auto). However, the default of pure vars in update definitions
// is RoundUp, which may introduces an out-of-bound error if it is an access
// to inputs or outputs.
//
// We could have just used GuardWithIf when splitting pure vars in update
// definition to ensure no out-of-bounds error. However, this is only
// necessary, if the update definition involves accesses to inputs or outputs.
// For other accesses, we could potentially use a more aggressive tail strategy
// such as RoundUp or ShiftInwards. Note that if we use RoundUp or ShiftInwards,
// any nested loops (generated by compute_at) will be affected as well. However,
// since in the current auto-scheduler model, we always compute_at at the group
// output, if the update definition is not the group output, we do not need to
// care for the nested loops. If it is the update definition of the group output
// however, we'd better make sure that no other member of the groups accesses
// the inputs or outputs.
TailStrategy strategy = TailStrategy::Auto;
if ((stage_num > 0) && !v.is_rvar) {
if (!is_group_output) {
if (access_inputs_or_outputs(def, v, costs.inputs, outputs)) {
strategy = TailStrategy::GuardWithIf;
}
} else {
bool any_access_inputs_outputs = false;
for (const FStage &mem : g.members) {
if (mem.func.name() == f_handle.name()) {
continue;
}
Definition mem_def = get_stage_definition(mem.func, mem.stage_num);
if (access_inputs_or_outputs(mem_def, v, costs.inputs, outputs)) {
any_access_inputs_outputs = true;
break;
}
}
if (any_access_inputs_outputs) {
strategy = TailStrategy::GuardWithIf;
}
}
}
f_handle.split(v, outer, inner, factor, strategy);
std::ostringstream oss;
oss << "split(" << arg_name << ", " << outer_name << ", " << inner_name << ", " << factor;
switch (strategy) {
case TailStrategy::RoundUp:
oss << ", TailStrategy::RoundUp)";
break;
case TailStrategy::GuardWithIf:
oss << ", TailStrategy::GuardWithIf)";
break;
case TailStrategy::ShiftInwards:
oss << ", TailStrategy::ShiftInwards)";
break;
case TailStrategy::Auto:
oss << ")";
break;
default:
internal_assert(false);
}
sched.push_schedule(f_handle.name(), stage_num, oss.str(),
{arg_name, outer_name, inner_name});
const Expr &est = get_element(estimates, arg_name);
internal_assert(est.defined());
estimates[inner_name] = factor;
estimates[outer_name] = simplify((est + factor - 1) / factor);
estimates.erase(arg_name);
return make_pair(inner, outer);
}
void Partitioner::vectorize_stage(const Group &g, Stage f_handle, int stage_num,
Definition def, Function func, bool is_group_output,
const Target &t, set<string> &rvars,
map<string, Expr> &estimates, AutoSchedule &sched) {
vector<Dim> &dims = def.schedule().dims();
int vec_dim_index = -1;
// Set the vector length as the maximum of the natural vector size of all
// values produced by the function.
int vec_len = 0;
for (const auto &type : func.output_types()) {
vec_len = std::max(vec_len, t.natural_vector_size(type));
}
for (int d = 0; d < (int) dims.size() - 1; d++) {
string dim_name = get_base_name(dims[d].var);
bool can_vectorize = true;
if (rvars.find(dim_name) != rvars.end()) {
can_vectorize = can_parallelize_rvar(dim_name, func.name(), def);
}
const auto &iter = estimates.find(dim_name);
if ((iter != estimates.end()) && iter->second.defined()) {
if (can_vectorize && can_prove(iter->second >= vec_len)) {
vec_dim_index = d;
break;
}
}
}
if (vec_dim_index >= 0) {
string vec_dim_name = get_base_name(dims[vec_dim_index].var);
bool is_rvar = (rvars.find(vec_dim_name) != rvars.end());
internal_assert(is_rvar == dims[vec_dim_index].is_rvar());
VarOrRVar vec_var(vec_dim_name, is_rvar);
pair<VarOrRVar, VarOrRVar> split_vars =
split_dim(g, f_handle, stage_num, def, is_group_output, vec_var, vec_len,
"_vi", "_vo", estimates, sched);
f_handle.vectorize(split_vars.first);
sched.push_schedule(f_handle.name(), stage_num,
"vectorize(" + split_vars.first.name() + ")",
{split_vars.first.name()});
if (is_rvar) {
rvars.erase(vec_dim_name);
rvars.insert(split_vars.first.name());
rvars.insert(split_vars.second.name());
}
// TODO: Reorder vector dim to innermost if it is the innermost
// storage dimension of the func.
//
// TODO: Check if the warning is necessary.
if (vec_dim_index > 0) {
user_warning << "Outer dim vectorization of var \"" << vec_dim_name
<< "\" in function \"" << f_handle.name() << "\"\n";
}
}
}
// Return true if the vars/rvars in 'ordering' are in the same order as the
// dim list.
inline bool operator==(const vector<Dim> &dims, const vector<VarOrRVar> &ordering) {
if (dims.size() != ordering.size() + 1) { // The dim list also contains '__outermost'
return false;
}
for (size_t i = 0; i < ordering.size(); ++i) {
if (dims[i].var != ordering[i].name()) {
return false;
}
}
return true;
}
// Return true if the vars/rvars in 'ordering' are not in the same order as the
// dim list.
inline bool operator!=(const vector<Dim> &dims, const vector<VarOrRVar> &ordering) {
return !(dims == ordering);
}
void Partitioner::reorder_dims(Stage f_handle, int stage_num, Definition def,
map<string, Expr> strides, AutoSchedule &sched) {
vector<Dim> &dims = def.schedule().dims();
internal_assert(dims.size() > 1);
vector<pair<string, int>> order;
for (int d = 0; d < (int)dims.size() - 1; d++) {
internal_assert(strides.find(dims[d].var) != strides.end());
}
// Iterate until all the dimensions have been assigned an order
while (strides.size() > 0) {
// Find the pure dimension (can be vars or rvars) with the smallest stride
bool found_pure_dim = false;
Expr min_pure_stride = Int(64).max();
string min_pure_var;
int min_pure_index = -1;
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var_name = get_base_name(dims[d].var);
const auto &iter = strides.find(var_name);
if ((iter != strides.end()) && dims[d].is_pure()) {
const Expr &dim_stride = iter->second;
internal_assert(dim_stride.defined());
if (can_prove(dim_stride < min_pure_stride)) {
min_pure_stride = dim_stride;
min_pure_var = var_name;
min_pure_index = d;
}
found_pure_dim = true;
}
}
if (found_pure_dim && min_pure_var.empty()) {
// Since none of the pure strides can be proven as the minimum, we
// should break here otherwise it may cause infinite loop.
return;
}
// Check if the stride of the pure dimension is smaller than
// the first impure dimension that has not yet been assigned
// an order
Expr min_impure_stride = Int(64).max();
string min_impure_var;
int min_impure_index = -1;
for (int d = 0; d < (int)dims.size() - 1; d++) {
string var_name = get_base_name(dims[d].var);
const auto &iter = strides.find(var_name);
if ((iter != strides.end()) && !dims[d].is_pure()) {
const Expr &dim_stride = iter->second;
internal_assert(dim_stride.defined());
if (can_prove(dim_stride < min_impure_stride)) {
min_impure_stride = dim_stride;
min_impure_var = var_name;
min_impure_index = d;
// Impure dimensions cannot be reordered relative to
// each other. Stop after encountering the first impure
// dimension.
break;
}
}
}
if (min_pure_var.empty() && min_impure_var.empty()) {
// Since none of the pure and impure strides can be proven as the
// minimum, we should break here otherwise it may cause infinite loop.
return;
}
pair<string, int> curr_min_var;
if (!min_impure_var.empty() && can_prove(min_impure_stride < min_pure_stride)) {
curr_min_var.first = min_impure_var;
curr_min_var.second = min_impure_index;
internal_assert(dims[min_impure_index].is_rvar());
} else {
curr_min_var.first = min_pure_var;
curr_min_var.second = min_pure_index;
}
order.push_back(curr_min_var);
strides.erase(curr_min_var.first);
}
vector<VarOrRVar> ordering;
for (const auto &o : order) {
VarOrRVar o_var(o.first, dims[o.second].is_rvar());
ordering.push_back(o_var);
}
internal_assert(!ordering.empty());
set<string> var_list = {ordering[0].name()};
string var_order = ordering[0].name();
for (size_t o = 1; o < ordering.size(); o++) {
var_order += ", " + ordering[o].name();
var_list.insert(ordering[o].name());
}
if (dims != ordering) {
f_handle.reorder(ordering);
sched.push_schedule(f_handle.name(), stage_num, "reorder(" + var_order + ")", var_list);
}
}
// Visitor to find all the variables the depend on a variable.
class FindVarsUsingVar : public IRVisitor {
using IRVisitor::visit;
void visit(const Let *let) {
if (expr_uses_vars(let->value, vars)) {
vars.push(let->name);
}
let->value.accept(this);
let->body.accept(this);
}
public :
Scope<> vars;
FindVarsUsingVar(string var) {
vars.push(var);
}
};
void Partitioner::generate_group_cpu_schedule(
const Group &g, const Target &t,
const map<FStage, DimBounds> &group_loop_bounds,
const map<string, Box> &group_storage_bounds,
const set<string> &inlines,
AutoSchedule &sched) {
string out_f_name = g.output.func.name();
Function g_out = g.output.func;
debug(3) << "\n================\n";
debug(3) << "Scheduling group:\n";
debug(3) << "================\n";
debug(3) << g;
if (g.output.func.has_extern_definition()) {
internal_assert(g.members.size() == 1);
Func(g_out).compute_root();
sched.push_schedule(g_out.name(), g.output.stage_num, "compute_root()", {});
return;
}
// Get the estimates for stage bounds
DimBounds stg_bounds = get_bounds(g.output);
map<string, Expr> stg_estimates = bounds_to_estimates(stg_bounds);
Stage f_handle = Stage(Func(g_out));
// Get a function handle for scheduling the stage
if (g.output.stage_num > 0) {
int stage_num = g.output.stage_num;
f_handle = Func(g_out).update(stage_num - 1);
} else {
Func(g_out).compute_root();
sched.push_schedule(f_handle.name(), g.output.stage_num, "compute_root()", {});
}
// Realize tiling and update the dimension estimates
vector<VarOrRVar> outer_dims;
vector<VarOrRVar> inner_dims;
// Get the definition corresponding to the stage
Definition def = get_stage_definition(g_out, g.output.stage_num);
// 'dims' will get modified since we are going to apply the schedules
// (e.g. tiling, reordering, etc.)
vector<Dim> &dims = def.schedule().dims();
// Keep track of the rvars
set<string> rvars;
for (int d = 0; d < (int)dims.size() - 1; d++) {
if (dims[d].is_rvar()) {
rvars.insert(get_base_name(dims[d].var));
}
}
// Reorder the dimensions for better spatial locality (i.e. smallest stride
// is innermost). If we only have one dimension (excluding __outermost),
// there is nothing to reorder.
if (dims.size() > 2) {
map<string, Expr> strides =
analyze_spatial_locality(g.output, group_storage_bounds, inlines);
if (!strides.empty()) {
reorder_dims(f_handle, g.output.stage_num, def, strides, sched);
}
}
vector<string> dim_vars(dims.size() - 1);
for (int d = 0; d < (int)dims.size() - 1; d++) {
dim_vars[d] = get_base_name(dims[d].var);
}
// Apply tiling to output of the group
for (const auto &var : dim_vars) {
bool is_rvar = (rvars.find(var) != rvars.end());
VarOrRVar v(var, is_rvar);
const auto &iter = g.tile_sizes.find(var);
if ((iter != g.tile_sizes.end()) &&
get_element(stg_estimates, var).defined() &&
can_prove(get_element(stg_estimates, var) > iter->second)) {
const Expr &tile_size = iter->second;
if (can_prove(tile_size == 1)) {
outer_dims.push_back(v);
} else {
pair<VarOrRVar, VarOrRVar> tile_vars =
split_dim(g, f_handle, g.output.stage_num, def, true, v,
tile_size, "_i", "_o", stg_estimates, sched);
inner_dims.push_back(tile_vars.first);
outer_dims.push_back(tile_vars.second);
if (is_rvar) {
rvars.erase(var);
rvars.insert(tile_vars.first.name());
rvars.insert(tile_vars.second.name());
}
}
} else {
inner_dims.push_back(v);
}
}
// Reorder the tile dimensions
if (!outer_dims.empty()) {
vector<VarOrRVar> ordering;
for (const auto &v : inner_dims) {
ordering.push_back(v);
}
for (const auto &v : outer_dims) {
ordering.push_back(v);
}
set<string> var_list;
string var_order = ordering[0].name();
for (size_t o = 1; o < ordering.size(); o++) {
var_order += ", " + ordering[o].name();
var_list.insert(ordering[o].name());
}
if (dims != ordering) {
f_handle.reorder(ordering);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"reorder(" + var_order + ")", var_list);
}
}
vectorize_stage(g, f_handle, g.output.stage_num, def, g_out, true, t,
rvars, stg_estimates, sched);
// Parallelize definition
Expr def_par = 1;
// TODO: Investigate if it is better to pull one large dimension and
// parallelize over it or to generate nested parallelism.
//
// Go from the outer to the innermost loop until sufficient parallelism
// is achieved. Stop the search once we find a vectorized dimension since
// it doesn't make any sense to have a parallelized inner loop within a
// vectorized outer loop.
bool nested_parallelism = true;
if (nested_parallelism) {
int dim_start = dims.size() - 2;
string seq_var = "";
for (int d = dim_start; d >= 0; d--) {
if (dims[d].for_type == ForType::Vectorized) {
break;
}
string var = get_base_name(dims[d].var);
bool is_rvar = (rvars.find(var) != rvars.end());
internal_assert(is_rvar == dims[d].is_rvar());
VarOrRVar v(var, is_rvar);
if (is_rvar && !can_parallelize_rvar(var, g_out.name(), def)) {
if (seq_var == "") {
seq_var = var;
}
continue;
}
if (can_prove(def_par >= arch_params.parallelism)) {
// Enough parallelism to saturate target machine
break;
}
const auto &iter = stg_estimates.find(var);
if ((iter != stg_estimates.end()) && iter->second.defined()) {
if (seq_var != "") {
VarOrRVar seq(seq_var, (rvars.find(seq_var) != rvars.end()));
f_handle.reorder(seq, v);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"reorder(" + seq_var + ", " + var + ")",
{seq_var, var});
}
f_handle.parallel(v);
sched.push_schedule(f_handle.name(), g.output.stage_num,
"parallel(" + var + ")", {var});
def_par = simplify(def_par * iter->second);
} else {
break;
}
}
}
if (can_prove(def_par < arch_params.parallelism)) {
user_warning << "Insufficient parallelism for " << f_handle.name() << '\n';
}
// Find the level at which group members will be computed.
int tile_inner_index = dims.size() - outer_dims.size() - 1;
VarOrRVar tile_inner_var("", false);
if (!outer_dims.empty()) {
string var_name = get_base_name(dims[tile_inner_index].var);
bool is_rvar = (rvars.find(var_name) != rvars.end());
tile_inner_var = VarOrRVar(var_name, is_rvar);
}
for (const FStage &mem : g.members) {
// Skip member stages that have been inlined or stage that is the
// output stage of the group
if ((g.inlined.find(mem.func.name()) != g.inlined.end()) ||
(mem.func.name() == g_out.name())) {
continue;
}
// Get the definition corresponding to the stage
Definition mem_def = get_stage_definition(mem.func, mem.stage_num);
// Get the estimates for the dimensions of the member stage
map<string, Expr> mem_estimates =
bounds_to_estimates(get_element(group_loop_bounds, mem));
set<string> mem_rvars;
vector<Dim> &mem_dims = mem_def.schedule().dims();
for (int d = 0; d < (int)mem_dims.size() - 1; d++) {
if (mem_dims[d].is_rvar()) {
mem_rvars.insert(get_base_name(mem_dims[d].var));
}
}
// Get a function handle for scheduling the stage
Stage mem_handle = Stage(Func(mem.func));
if (mem.stage_num > 0) {
mem_handle = Func(mem.func).update(mem.stage_num - 1);
} else {
if (!outer_dims.empty()) {
if (tile_inner_var.is_rvar) {
Func(mem.func).compute_at(Func(g_out), tile_inner_var.rvar);
} else {
Func(mem.func).compute_at(Func(g_out), tile_inner_var.var);
}
string sanitized_g_out = get_sanitized_name(g_out.name());
sched.push_schedule(mem_handle.name(), mem.stage_num,
"compute_at(" + sanitized_g_out + ", " + tile_inner_var.name() + ")",
{sanitized_g_out, tile_inner_var.name()});
} else {
user_warning << "Degenerate tiling. No dimensions are tiled" << '\n';
user_warning << "Computing \"" << mem.func.name() << "\" at root" << '\n';
Func(mem.func).compute_root();
sched.push_schedule(mem_handle.name(), mem.stage_num, "compute_root()", {});
}
}
// Reorder the dimensions for better spatial locality. If we only have
// one dimension (excluding __outermost), there is nothing to reorder.
if (dims.size() > 2) {
map<string, Expr> mem_strides =
analyze_spatial_locality(mem, group_storage_bounds, inlines);
if (!mem_strides.empty()) {
reorder_dims(mem_handle, mem.stage_num, mem_def, mem_strides, sched);
}
}
vectorize_stage(g, mem_handle, mem.stage_num, mem_def, mem.func, false,
t, mem_rvars, mem_estimates, sched);
}
}
void Partitioner::generate_cpu_schedule(const Target &t, AutoSchedule &sched) {
// Grab the group bounds early as they rely on the dimensions of the group
// outputs which will be altered by modifying schedules.
map<FStage, map<FStage, DimBounds>> loop_bounds = group_loop_bounds();
map<FStage, map<string, Box>> storage_bounds = group_storage_bounds();
set<string> inlines;
// Mark all functions that are inlined.
for (const pair<FStage, Group> &g : groups) {
for (const string &inline_func : g.second.inlined) {
inlines.insert(inline_func);
}
}
// TODO: Inlining functions with update definitions has different
// behavior than pure functions. They may need to be computed above
// the innermost vector loop to avoid complications with varying
// extents across different vector lanes.
//
// Since the default schedule is compute inline, we don't need to
// explicitly call compute_inline() on the function.
// Realize schedule for each group in the pipeline.
for (const auto &g : groups) {
generate_group_cpu_schedule(g.second, t, get_element(loop_bounds, g.first),
get_element(storage_bounds, g.first), inlines, sched);
}
}
Expr Partitioner::find_max_access_stride(const Scope<> &vars,
const string &func_acc,
const vector<Expr> &acc_exprs,
const Box &buffer_bounds) {
size_t num_storage_dims = 0;
Expr bytes_per_ele = make_zero(Int(64));
// Get the number of dimensions of the allocated storage and the
// number of bytes required to store a single value of func_acc.
const auto &iter = dep_analysis.env.find(func_acc);
if (iter != dep_analysis.env.end()) {
const Function &f = iter->second;
for (const auto &e : f.values()) {
bytes_per_ele += e.type().bytes();
}
num_storage_dims = f.schedule().storage_dims().size();
} else {
bytes_per_ele = get_element(costs.inputs, func_acc).bytes();
num_storage_dims = buffer_bounds.size();
}
Expr curr_stride = bytes_per_ele;
Expr stride = make_zero(Int(64));
internal_assert(num_storage_dims <= acc_exprs.size());
for (size_t sdim = 0; sdim < num_storage_dims; sdim++) {
// Check if the access expression depends on any of the loop variables
// in 'vars'. Expressions that do not involve the variable have stride 0.
if (expr_uses_vars(acc_exprs[sdim], vars)) {
stride = max(stride, curr_stride);
}
const Interval &dim_range = buffer_bounds[sdim];
Expr dim_extent = get_extent(dim_range);
if (!dim_extent.defined()) {
return Expr();
}
curr_stride *= dim_extent;
}
return simplify(stride);
}
map<string, Expr>
Partitioner::analyze_spatial_locality(const FStage &stg,
const map<string, Box> &allocation_bounds,
const set<string> &inlines) {
internal_assert(!stg.func.has_extern_definition());
// Handle inlining. When a function is inlined into another, the stride of
// the accesses should be computed on the expression post inlining.
// For example:
// f(x, y) = ...;
// g(x, y) = f(y, x); // transpose
// h(x, y) = g(y, x); // transpose
//
// If both g and f are inlined into h, then the resulting expression for h
// will look like:
// h(x, y) = f(x, y);
//
// Computing the stride of a loop over x in the function h will be incorrect
// if inlining is not taken into account.
// Get all the allocations accessed in the definition corresponding to 'stg'.
FindAllCalls find;
Definition def = get_stage_definition(stg.func, stg.stage_num);
// Perform inlining on the all the values and the args in the stage.
for (auto &val : def.values()) {
val = perform_inline(val, dep_analysis.env, inlines);
}
for (auto &arg : def.args()) {
arg = perform_inline(arg, dep_analysis.env, inlines);
}
def.accept(&find);
// Arguments on the left hand side might themselves involve accesses
// to allocations and thus need to be accounted for when computing the
// strides along each dimension.
vector<pair<string, vector<Expr>>> &call_args = find.call_args;
// Account for the spatial locality of the store. Add the access on the
// left hand side to call_args.
call_args.push_back(make_pair(stg.func.name(), def.args()));
// Map for holding the strides across each dimension
map<string, Expr> var_strides;
const vector<Dim> &dims = def.schedule().dims();
for (int d = 0; d < (int)dims.size() - 1; d++) {
// Get all the variables involving the dimension in the definition.
FindVarsUsingVar dep_vars(dims[d].var);
def.accept(&dep_vars);
// Accumulate the stride of each access to a loop dimension.
Expr total_stride = 0;
for (const pair<string, vector<Expr>> &call : call_args) {
Box call_alloc_reg;
const auto &iter = allocation_bounds.find(call.first);
if (iter != allocation_bounds.end()) {
call_alloc_reg = iter->second;
} else {
call_alloc_reg = get_element(pipeline_bounds, call.first);
}
Expr current_stride = find_max_access_stride(dep_vars.vars, call.first,
call.second, call_alloc_reg);
if (!current_stride.defined()) {
return map<string, Expr>();
}
total_stride += current_stride;
}
var_strides.emplace(dims[d].var, simplify(total_stride));
}
return var_strides;
}
// Verify that function 'f' does not have partially specified schedules/bounds.
// The current auto scheduler cannots handle such cases.
void validate_no_partial_schedules(const Function &f) {
if (f.has_extern_definition()) {
return;
}
// Verify no compute_root or bounds are specified
user_assert(f.schedule().compute_level().is_inlined())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it is scheduled to be computed at root\n";
user_assert(f.schedule().bounds().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has partially specified bounds\n";
int num_stages = f.updates().size() + 1;
for (int stage = 0; stage < num_stages; ++stage) {
const Definition &def = get_stage_definition(f, stage);
const StageSchedule &schedule = def.schedule();
// Verify no splits are specified
user_assert(schedule.splits().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has partially specified schedules at stage " << stage << "\n";
// Verify that none of the dimensions are scheduled to be parallelized or
// vectorized, or unrolled.
for (const auto &d : schedule.dims()) {
user_assert(d.for_type == ForType::Serial)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since stage " << stage << " is not serial at dim " << d.var << "\n";
}
if (stage == 0) {
// Since we can only specialize on a Func, we only need to check for no
// specializations for the initial stage.
user_assert(def.specializations().empty())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since it has specializations\n";
// Verify that there is no loop reordering on the initial definition
// (i.e. the Vars in the dim list should be in the same order as
// the args in the LHS of the definition).
internal_assert(schedule.dims().size() - 1 == def.args().size());
for (size_t i = 0; i < def.args().size(); ++i) {
const Variable *arg = def.args()[i].as<Variable>();
internal_assert(arg);
user_assert(arg->name == schedule.dims()[i].var)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << arg->name << "\" at stage " << stage
<< " has been reordered\n";
}
} else {
// Verify that there is no loop reordering on the update definition
// (i.e. the Vars in the dim list should be in the same order as
// the args in the LHS of the definition, the RVars in the dim list
// should be in the same order as the RVars in the rvar list, and
// all RVars should come before all Vars).
const vector<Dim> &dims = schedule.dims();
const vector<ReductionVariable> &rvars = schedule.rvars();
const vector<Expr> &args = f.definition().args();
internal_assert(dims.size() - 1 >= rvars.size());
for (size_t i = 0; i < rvars.size(); ++i) {
const Dim &d = dims[i];
user_assert(d.is_rvar() && (d.var == rvars[i].var))
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
}
internal_assert(dims.size() - rvars.size() - 1 <= args.size());
int last_index = -1;
for (int i = rvars.size(); i < (int)dims.size() - 1; ++i) {
const Dim &d = dims[i];
user_assert(!d.is_rvar())
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
const auto &iter =
std::find_if(args.begin(), args.end(),
[&d](const Expr &arg) {
const Variable *v = arg.as<Variable>();
return (d.var == v->name);
});
internal_assert(iter != args.end());
int current_index = iter - args.begin();
user_assert(current_index > last_index)
<< "AutoSchedule: cannot auto-schedule function \"" << f.name()
<< "\" since dim \"" << i << "\" at stage " << stage
<< " has been reordered\n";
last_index = current_index;
}
}
}
}
// Determine if a Func (order[index]) is only consumed by another single Func
// in element-wise manner. If it is, return the name of the consumer Func;
// otherwise, return an empty string.
string is_func_called_element_wise(const vector<string> &order, size_t index,
const map<string, Function> &env) {
Function f1 = env.at(order[index]);
if (f1.has_extern_definition() || !f1.can_be_inlined()) {
return "";
}
internal_assert(index < order.size());
string caller = "";
for (size_t i = index + 1; i < order.size(); ++i) {
Function f2 = env.at(order[i]);
if (f2.has_extern_definition()) {
continue;
}
int num_stages = f2.updates().size() + 1;
for (int s = 0; s < num_stages; ++s) {
Definition def = get_stage_definition(f2, s);
FindAllCalls find;
def.accept(&find);
if (find.funcs_called.count(f1.name())) {
if (caller.empty()) {
caller = f2.name();
} else {
// Found another caller of 'f1'
return "";
}
}
for (const auto &iter : find.call_args) {
if (iter.first != f1.name()) {
continue;
}
if (def.args().size() != iter.second.size()) {
// It's not an element-wise access
return "";
}
for (size_t j = 0; j < iter.second.size(); ++j) {
if (!equal(def.args()[j], iter.second[j])) {
// It's not an element-wise access
return "";
}
}
}
}
}
return caller;
}
// Return true if 'f' is used by some extern Func.
bool used_by_extern_func(const map<string, Function> &env, const Function &f) {
for (const auto &iter : env) {
for (const ExternFuncArgument &arg : iter.second.extern_arguments()) {
if (arg.is_func()) {
if (Function(arg.func).name() == f.name()) {
return true;
}
}
}
}
return false;
}
// If the bounds of a Func are undefined, then we should just inline the Func
// as long as it is legal to inline or used by some extern Func.
set<string> get_unbounded_functions(const map<string, Box> &pipeline_bounds,
const map<string, Function> &env) {
set<string> unbounded;
for (const auto &iter : env) {
if (!pipeline_bounds.count(iter.first)) {
debug(5) << "...Skip checking function \"" << iter.first
<< "\" since it does not have pipeline bounds\n";
continue;
}
const Function &f = iter.second;
if (!f.can_be_inlined() || used_by_extern_func(env, f)) {
continue;
}
const Box &bound = get_element(pipeline_bounds, iter.first);
if (is_box_unbounded(bound)) {
unbounded.insert(iter.first);
}
}
return unbounded;
}
bool inline_unbounded(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env,
const set<string> &unbounded) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
Function f1 = env.at(order[i]);
if (!unbounded.count(f1.name())) {
continue;
}
inlined = true;
debug(4) << "Function \"" << order[i] << "\" is unbounded\n";
for (int j = i + 1; j < (int)order.size(); ++j) {
internal_assert(order[i] != order[j]);
Function f2 = env.at(order[j]);
debug(5) << "Inline unbounded function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\"\n";
inline_function(f2, f1);
}
}
return inlined;
}
} // anonymous namespace
// Check if all the pipeline outputs have estimates specified
// on each of their dimensions; otherwise, throw an assertion.
void check_estimates_on_outputs(const vector<Function> &outputs) {
for (const auto &out : outputs) {
const vector<Bound> &estimates = out.schedule().estimates();
// Check if the estimate for each dimension of the output is available
// and is an integer. If there are duplicates for the estimate of a
// dimension, we only check the last defined estimate (which min and
// extent values are defined) since it is the one that would be
// eventually used.
Bound est;
for (const auto &arg : out.args()) {
bool found = false;
for (int i = (int)estimates.size() - 1; i >= 0; --i) {
if ((estimates[i].var == arg) && estimates[i].min.defined() &&
estimates[i].extent.defined()) {
found = true;
est = estimates[i];
break;
}
}
user_assert(found && est.min.type().is_int() && est.extent.type().is_int())
<< "Please provide a valid estimate for dimension "
<< est.var << " of output \"" << out.name() << "\"\n";
}
}
}
// If the cost of computing a Func is about the same as calling the Func,
// inline the Func. Return true of any of the Funcs is inlined.
bool inline_all_trivial_functions(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
bool is_output = false;
for (const Function &f : outputs) {
if (order[i] == f.name()) {
is_output = true;
break;
}
}
if (is_output) {
// Should not inline output Func
debug(5) << "Skip inlining " << order[i] << " since it is an output\n";
continue;
}
Function f1 = env.at(order[i]);
if (is_func_trivial_to_inline(f1)) {
inlined = true;
debug(4) << "Function \"" << order[i] << "\" is trivial to inline\n";
for (int j = i + 1; j < (int)order.size() - (int)outputs.size(); ++j) {
internal_assert(order[i] != order[j]);
Function f2 = env.at(order[j]);
if (f2.has_extern_definition() && !f1.is_wrapper()) {
debug(5) << "Skip inlining of function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\", because "
<< "non-wrapper functions cannot be inlined inside "
<< "extern functions.\n";
} else {
debug(5) << "Inline trivial function \"" << f1.name()
<< "\" inside \"" << f2.name() << "\"\n";
inline_function(f2, f1);
}
}
}
}
return inlined;
}
// Inline a Func if its values are only consumed by another single Func in
// element-wise manner.
bool inline_all_element_wise_functions(const vector<Function> &outputs,
const vector<string> &order,
const map<string, Function> &env) {
bool inlined = false;
// The very last few functions in 'order' are the last to be realized in the
// pipeline (the final producers) so there is no point in checking it.
for (int i = 0; i < (int)order.size() - (int)outputs.size(); ++i) {
bool is_output = false;
for (const Function &f : outputs) {
if (order[i] == f.name()) {
is_output = true;
break;
}
}
if (is_output) {
// Should not inline output Func
debug(5) << "Skip inlining " << order[i] << " since it is an output\n";
continue;
}
string caller = is_func_called_element_wise(order, i, env);
if (!caller.empty()) {
inlined = true;
debug(4) << "Inline function \"" << order[i] << "\" since it is called only by "
<< caller << " in element-wise manner\n";
internal_assert(order[i] != caller);
inline_function(env.at(caller), get_element(env, order[i]));
}
}
return inlined;
}
// Generate schedules for all functions in the pipeline required to compute the
// outputs. This applies the schedules and returns a string representation of
// the schedules. The target architecture is specified by 'target'.
string generate_schedules(const vector<Function> &outputs, const Target &target,
const MachineParams &arch_params) {
// Make an environment map which is used throughout the auto scheduling process.
map<string, Function> env;
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
// Finalize all the LoopLevels
for (auto &iter : env) {
iter.second.lock_loop_levels();
}
// Compute the topological order, before any trivial inlining (i.e. before
// we remove any functions from 'env'). We need the full topological
// order to pass to get_func() when generating the string representation
// of the schedule.
debug(2) << "Computing topological order...\n";
vector<string> top_order = topological_order(outputs, env);
// Validate that none of the functions in the pipeline have partial schedules.
debug(2) << "Validating no partial schedules...\n";
for (const auto &iter : env) {
validate_no_partial_schedules(iter.second);
}
// The auto scheduling algorithm requires estimates on the outputs of the
// pipeline to get quantitative estimates of costs for computing functions
// in the pipeline.
debug(2) << "Checking estimates on outputs...\n";
check_estimates_on_outputs(outputs);
// Run a pre-pass that inline all trivial Funcs (i.e. if the cost of
// computing a Func is about the same as calling that Func, we should
// just inline it).
debug(2) << "Inlining all trivial functions...\n";
if (inline_all_trivial_functions(outputs, top_order, env)) {
// If any of the Funcs is inlined, we need to recompute 'env', since some
// of the Funcs are no longer used and need to be removed from 'env'.
//
// Instead of recomputing 'env', we could also remove the inlined Func
// within inline_all_trivial_functions(); however, it is a bit tricky
// to do when dealing with inlined tuple. Consider the following case:
// f(x, y) = x + y;
// g(x, y) = {x, f(x, y)};
// h(x, y) = g(x, y)[0];
// When 'g' is inlined in 'h', no one uses 'f' anymore and it can
// be removed from 'env'. However, to know this, we need to trace
// all the function calls within the pipeline. Thus, we might as well
// recompute the 'env' from scratch.
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
}
// Compute the realization order of the functions within the pipeline.
vector<string> order = realization_order(outputs, env).first;
// Run a pre-pass that inline all Funcs which values are accessed by
// another single Func in element-wise manner. We need to do this
// repeatedly since some inlining decisions may enable further inlining
// that previously not possible. Consider the following case:
// f1(x) = x;
// f2(x) = f1(x) + 2;
// f3(x) = f1(x) * 2;
// f4(x) = f2(x) + f3(x);
// f5(x) = f4(x) + 3;
// In the first iteration, we cannot inline 'f1' since it is used by two
// functions: 'f2' and 'f3'. If 'f2' and 'f4' get inlined and 'f3' is only
// used by 'f4', then 'f1' can now also be inlined.
debug(2) << "Inlining all element-wise functions...\n";
while (inline_all_element_wise_functions(outputs, order, env)) {
// We need to recompute 'env' for the same reason as with
// inline_all_trivial_functions
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
order = realization_order(outputs, env).first;
}
// Compute the bounds of function values which are used for dependence analysis.
debug(2) << "Computing function value bounds...\n";
FuncValueBounds func_val_bounds = compute_function_value_bounds(order, env);
// Initialize the cost model.
// Compute the expression costs for each function in the pipeline.
debug(2) << "Initializing region costs...\n";
RegionCosts costs(env);
if (debug::debug_level() >= 3) {
costs.disp_func_costs();
}
debug(2) << "Initializing dependence analysis...\n";
DependenceAnalysis dep_analysis(env, order, func_val_bounds);
// Compute bounds of all functions in the pipeline given estimates on
// outputs. Also report functions which bounds could not be inferred.
debug(2) << "Computing pipeline bounds...\n";
map<string, Box> pipeline_bounds =
get_pipeline_bounds(dep_analysis, outputs, &costs.input_estimates);
// Determine all unbounded functions that are not extern Func or
// used by some extern Funcs.
debug(2) << "Determining all unbounded functions...\n";
set<string> unbounded = get_unbounded_functions(pipeline_bounds, env);
if (!unbounded.empty()) {
// If some functions are unbounded, we should inline those directly.
// Also, we need to recompute 'env' and re-initialize 'costs' and
// 'dep_analysis'
debug(2) << "Inlining all unbounded functions...\n";
internal_assert(inline_unbounded(outputs, order, env, unbounded));
env.clear();
for (Function f : outputs) {
map<string, Function> more_funcs = find_transitive_calls(f);
env.insert(more_funcs.begin(), more_funcs.end());
}
order = realization_order(outputs, env).first;
debug(2) << "Re-computing function value bounds...\n";
func_val_bounds = compute_function_value_bounds(order, env);
debug(2) << "Re-initializing region costs...\n";
RegionCosts costs(env);
debug(2) << "Re-initializing dependence analysis...\n";
dep_analysis = DependenceAnalysis(env, order, func_val_bounds);
debug(2) << "Re-computing pipeline bounds...\n";
pipeline_bounds = get_pipeline_bounds(dep_analysis, outputs, &costs.input_estimates);
}
debug(2) << "Initializing partitioner...\n";
Partitioner part(pipeline_bounds, arch_params, outputs, dep_analysis, costs);
// Compute and display reuse
/* TODO: Use the reuse estimates to reorder loops
for (const auto &f : env) {
FindAllCalls find;
f.second.accept(&find);
int num_stages = f.second.updates().size() + 1;
for (int s = 0; s < num_stages; s++) {
FStage curr_s(f.second, s);
map<string, Expr> reuse = part.evaluate_reuse(curr_s, find.funcs_called);
debug(0) << curr_s << '\n';
for (const auto &dir : reuse) {
debug(0) << dir.first << " " << dir.second << ',';
}
debug(0) << '\n';
}
}*/
// Display the current pipeline graph.
// TODO: Output the graph in dot format.
if (debug::debug_level() >= 3) {
part.disp_pipeline_graph();
part.disp_pipeline_bounds();
}
debug(2) << "Partitioner initializing groups...\n";
part.initialize_groups();
if (debug::debug_level() >= 3) {
part.disp_pipeline_costs();
}
// /////////////
// Remove the following two stages?
debug(2) << "Partitioner computing inline group...\n";
part.group(Partitioner::Level::Inline);
if (debug::debug_level() >= 3) {
part.disp_grouping();
}
debug(2) << "Partitioner computing fast-mem group...\n";
part.grouping_cache.clear();
part.group(Partitioner::Level::FastMem);
if (debug::debug_level() >= 3) {
part.disp_pipeline_costs();
part.disp_grouping();
part.disp_pipeline_graph();
}
debug(2) << "Initializing AutoSchedule...\n";
AutoSchedule sched(env, top_order);
debug(2) << "Generating CPU schedule...\n";
part.generate_cpu_schedule(target, sched);
std::ostringstream oss;
oss << "// Target: " << target.to_string() << "\n";
oss << "// MachineParams: " << arch_params.to_string() << "\n";
oss << "\n";
oss << sched;
string sched_string = oss.str();
debug(3) << "\n\n*******************************\nSchedule:\n"
<< "*******************************\n" << sched_string << "\n\n";
// TODO: Unify both inlining and grouping for fast mem
// TODO: GPU scheduling
// TODO: Hierarchical tiling
return sched_string;
}
} // namespace Internal
MachineParams MachineParams::generic() {
return MachineParams(16, 16 * 1024 * 1024, 40);
}
std::string MachineParams::to_string() const {
internal_assert(parallelism.type().is_int() &&
last_level_cache_size.type().is_int() &&
balance.type().is_int());
std::ostringstream o;
o << parallelism << "," << last_level_cache_size << "," << balance;
return o.str();
}
MachineParams::MachineParams(const std::string &s) {
std::vector<std::string> v = Internal::split_string(s, ",");
user_assert(v.size() == 3) << "Unable to parse MachineParams: " << s;
parallelism = Internal::string_to_int(v[0]);
last_level_cache_size = Internal::string_to_int(v[1]);
balance = Internal::string_to_int(v[2]);
}
} // namespace Halide
| 41.363916 | 113 | 0.57346 | jrk |
b45b35f0359a6a9d27c553b0c79426030e1966c2 | 9,840 | hpp | C++ | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | utilities/drv_imu_invensense_def.hpp | JerrySkywalker/HITSIC_Module | 8123ae5de95dddaaf6e65d35881ce271f43dad6b | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2018 - 2019 HITSIC
* 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.
*/
/**
* @brief 陀螺仪驱动，适用于mpu6050,mpu9250,icm20602
* @author xiao qq1761690868
* @doc drv_imu_invensense.md
* @version v1.0
* @date 2020-10-16
*/
#ifndef UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP
#define UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP
#include "hitsic_common.h"
#if (defined(HITSIC_USE_DRV_IMU_INV) && (HITSIC_USE_DRV_IMU_INV > 0U))
namespace inv {
enum class icm20602_RegMap :uint8_t
{
XG_OFFS_TC_H = 0x4, // READ/ WRITE
XG_OFFS_TC_L = 0x5, // READ/ WRITE
YG_OFFS_TC_H = 0x7, // READ/ WRITE
YG_OFFS_TC_L = 0x8, // READ/ WRITE
ZG_OFFS_TC_H = 0x0A, // READ/ WRITE
ZG_OFFS_TC_L = 0x0B, // READ/ WRITE
SELF_TEST_X_ACCEL = 0x0D, // READ/ WRITE
SELF_TEST_Y_ACCEL = 0x0E, // READ/ WRITE
SELF_TEST_Z_ACCEL = 0x0F, // READ/ WRITE
XG_OFFS_USRH = 0x13, // READ/ WRITE
XG_OFFS_USRL = 0x14, // READ/ WRITE
YG_OFFS_USRH = 0x15, // READ/ WRITE
YG_OFFS_USRL = 0x16, // READ/ WRITE
ZG_OFFS_USRH = 0x17, // READ/ WRITE
ZG_OFFS_USRL = 0x18, // READ/ WRITE
SMPLRT_DIV = 0x19, // READ/ WRITE
CONFIG = 0x1A, // READ/ WRITE default value:0x80
GYRO_CONFIG = 0x1B, // READ/ WRITE
ACCEL_CONFIG = 0x1C, // READ/ WRITE
ACCEL_CONFIG2 = 0x1D, // READ/ WRITE
LP_MODE_CFG = 0x1E, // READ/ WRITE
ACCEL_WOM_X_THR = 0x20, // READ/ WRITE
ACCEL_WOM_Y_THR = 0x21, // READ/ WRITE
ACCEL_WOM_Z_THR = 0x22, // READ/ WRITE
FIFO_EN = 0x23, // READ/ WRITE
FSYNC_INT = 0x36, // READ to CLEAR
INT_PIN_CFG = 0x37, // READ/ WRITE
INT_ENABLE = 0x38, // READ/ WRITE
FIFO_WM_INT_STATUS = 0x39, // READ to CLEAR
INT_STATUS = 0x3A, // READ to CLEAR
ACCEL_XOUT_H = 0x3B, // READ
ACCEL_XOUT_L = 0x3C, // READ
ACCEL_YOUT_H = 0x3D, // READ
ACCEL_YOUT_L = 0x3E, // READ
ACCEL_ZOUT_H = 0x3F, // READ
ACCEL_ZOUT_L = 0x40, // READ
TEMP_OUT_H = 0x41, // READ
TEMP_OUT_L = 0x42, // READ
GYRO_XOUT_H = 0x43, // READ
GYRO_XOUT_L = 0x44, // READ
GYRO_YOUT_H = 0x45, // READ
GYRO_YOUT_L = 0x46, // READ
GYRO_ZOUT_H = 0x47, // READ
GYRO_ZOUT_L = 0x48, // READ
SELF_TEST_X_GYRO = 0x50, // READ/ WRITE
SELF_TEST_Y_GYRO = 0x51, // READ/ WRITE
SELF_TEST_Z_GYRO = 0x52, // READ/ WRITE
FIFO_WM_TH1 = 0x60, // READ/ WRITE
FIFO_WM_TH2 = 0x61, // READ/ WRITE
SIGNAL_PATH_RESET = 0x68, // READ/ WRITE
ACCEL_INTEL_CTRL = 0x69, // READ/ WRITE
USER_CTRL = 0x6A, // READ/ WRITE
PWR_MGMT_1 = 0x6B, // READ/ WRITE default value:0x41
PWR_MGMT_2 = 0x6C, // READ/ WRITE
I2C_IF = 0x70, // READ/ WRITE
FIFO_COUNTH = 0x72, // READ
FIFO_COUNTL = 0x73, // READ
FIFO_R_W = 0x74, // READ/ WRITE
WHO_AM_I = 0x75, // READ default value:0x12
XA_OFFSET_H = 0x77, // READ/ WRITE
XA_OFFSET_L = 0x78, // READ/ WRITE
YA_OFFSET_H = 0x7A, // READ/ WRITE
YA_OFFSET_L = 0x7B, // READ/ WRITE
ZA_OFFSET_H = 0x7D, // READ/ WRITE
ZA_OFFSET_L = 0x7E, // READ/ WRITE
};
enum class mpu6050_RegMap :uint8_t
{
SELF_TEST_X = 0x0D, //R/W
SELF_TEST_Y = 0x0E, //R/W
SELF_TEST_Z = 0x0F, //R/W
SELF_TEST_A = 0x10, //R/W
SMPLRT_DIV = 0x19, //R/W
CONFIG = 0x1A, //R/W
GYRO_CONFIG = 0x1B, //R/W
ACCEL_CONFIG = 0x1C, //R/W
FIFO_EN = 0x23, //R/W
I2C_MST_CTRL = 0x24, //R/W
I2C_SLV0_ADDR = 0x25, //R/W
I2C_SLV0_REG = 0x26, //R/W
I2C_SLV0_CTRL = 0x27, //R/W
I2C_SLV1_ADDR = 0x28, //R/W
I2C_SLV1_REG = 0x29, //R/W
I2C_SLV1_CTRL = 0x2A, //R/W
I2C_SLV2_ADDR = 0x2B, //R/W
I2C_SLV2_REG = 0x2C, //R/W
I2C_SLV2_CTRL = 0x2D, //R/W
I2C_SLV3_ADDR = 0x2E, //R/W
I2C_SLV3_REG = 0x2F, //R/W
I2C_SLV3_CTRL = 0x30, //R/W
I2C_SLV4_ADDR = 0x31, //R/W
I2C_SLV4_REG = 0x32, //R/W
I2C_SLV4_DO = 0x33, //R/W
I2C_SLV4_CTRL = 0x34, //R/W
I2C_SLV4_DI = 0x35, //R
I2C_MST_STATUS = 0x36, //R
INT_PIN_CFG = 0x37, //R/W
INT_ENABLE = 0x38, //R/W
INT_STATUS = 0x3A, //R
ACCEL_XOUT_H = 0x3B, //R
ACCEL_XOUT_L = 0x3C, //R
ACCEL_YOUT_H = 0x3D, //R
ACCEL_YOUT_L = 0x3E, //R
ACCEL_ZOUT_H = 0x3F, //R
ACCEL_ZOUT_L = 0x40, //R
TEMP_OUT_H = 0x41, //R
TEMP_OUT_L = 0x42, //R
GYRO_XOUT_H = 0x43, //R
GYRO_XOUT_L = 0x44, //R
GYRO_YOUT_H = 0x45, //R
GYRO_YOUT_L = 0x46, //R
GYRO_ZOUT_H = 0x47, //R
GYRO_ZOUT_L = 0x48, //R
EXT_SENS_DATA_00 = 0x49, //R
EXT_SENS_DATA_01 = 0x4A, //R
EXT_SENS_DATA_02 = 0x4B, //R
EXT_SENS_DATA_03 = 0x4C, //R
EXT_SENS_DATA_04 = 0x4D, //R
EXT_SENS_DATA_05 = 0x4E, //R
EXT_SENS_DATA_06 = 0x4F, //R
EXT_SENS_DATA_07 = 0x50, //R
EXT_SENS_DATA_08 = 0x51, //R
EXT_SENS_DATA_09 = 0x52, //R
EXT_SENS_DATA_10 = 0x53, //R
EXT_SENS_DATA_11 = 0x54, //R
EXT_SENS_DATA_12 = 0x55, //R
EXT_SENS_DATA_13 = 0x56, //R
EXT_SENS_DATA_14 = 0x57, //R
EXT_SENS_DATA_15 = 0x58, //R
EXT_SENS_DATA_16 = 0x59, //R
EXT_SENS_DATA_17 = 0x5A, //R
EXT_SENS_DATA_18 = 0x5B, //R
EXT_SENS_DATA_19 = 0x5C, //R
EXT_SENS_DATA_20 = 0x5D, //R
EXT_SENS_DATA_21 = 0x5E, //R
EXT_SENS_DATA_22 = 0x5F, //R
EXT_SENS_DATA_23 = 0x60, //R
I2C_SLV0_DO = 0x63, //R/W
I2C_SLV1_DO = 0x64, //R/W
I2C_SLV2_DO = 0x65, //R/W
I2C_SLV3_DO = 0x66, //R/W
I2C_MST_DELAY_CTRL = 0x67, //R/W
SIGNAL_PATH_RESET = 0x68, //R/W
USER_CTRL = 0x6A, //R/W
PWR_MGMT_1 = 0x6B, //R/W
PWR_MGMT_2 = 0x6C, //R/W
FIFO_COUNTH = 0x72, //R/W
FIFO_COUNTL = 0x73, //R/W
FIFO_R_W = 0x74, //R/W
WHO_AM_I = 0x75, //R
};
enum class mpu9250_RegMap :uint8_t
{
SELF_TEST_X_GYRO = 0x0,//R/W
SELF_TEST_Y_GYRO = 0x1,//R/W
SELF_TEST_Z_GYRO = 0x2,//R/W
SELF_TEST_X_ACCEL = 0x0D,//R/W
SELF_TEST_Y_ACCEL = 0x0E,//R/W
SELF_TEST_Z_ACCEL = 0x0F,//R/W
XG_OFFSET_H = 0x13,//R/W
XG_OFFSET_L = 0x14,//R/W
YG_OFFSET_H = 0x15,//R/W
YG_OFFSET_L = 0x16,//R/W
ZG_OFFSET_H = 0x17,//R/W
ZG_OFFSET_L = 0x18,//R/W
SMPLRT_DIV = 0x19,//R/W
CONFIG = 0x1A,//R/W
GYRO_CONFIG = 0x1B,//R/W
ACCEL_CONFIG = 0x1C,//R/W
ACCEL_CONFIG2 = 0x1D,//R/W
LP_ACCEL_ODR = 0x1E,//R/W
WOM_THR = 0x1F,//R/W
FIFO_EN = 0x23,//R/W
I2C_MST_CTRL = 0x24,//R/W
I2C_SLV0_ADDR = 0x25,//R/W
I2C_SLV0_REG = 0x26,//R/W
I2C_SLV0_CTRL = 0x27,//R/W
I2C_SLV1_ADDR = 0x28,//R/W
I2C_SLV1_REG = 0x29,//R/W
I2C_SLV1_CTRL = 0x2A,//R/W
I2C_SLV2_ADDR = 0x2B,//R/W
I2C_SLV2_REG = 0x2C,//R/W
I2C_SLV2_CTRL = 0x2D,//R/W
I2C_SLV3_ADDR = 0x2E,//R/W
I2C_SLV3_REG = 0x2F,//R/W
I2C_SLV3_CTRL = 0x30,//R/W
I2C_SLV4_ADDR = 0x31,//R/W
I2C_SLV4_REG = 0x32,//R/W
I2C_SLV4_DO = 0x33,//R/W
I2C_SLV4_CTRL = 0x34,//R/W
I2C_SLV4_DI = 0x35,//R
I2C_MST_STATUS = 0x36,//R
INT_PIN_CFG = 0x37,//R/W
INT_ENABLE = 0x38,//R/W
INT_STATUS = 0x3A,//R
ACCEL_XOUT_H = 0x3B,//R
ACCEL_XOUT_L = 0x3C,//R
ACCEL_YOUT_H = 0x3D,//R
ACCEL_YOUT_L = 0x3E,//R
ACCEL_ZOUT_H = 0x3F,//R
ACCEL_ZOUT_L = 0x40,//R
TEMP_OUT_H = 0x41,//R
TEMP_OUT_L = 0x42,//R
GYRO_XOUT_H = 0x43,//R
GYRO_XOUT_L = 0x44,//R
GYRO_YOUT_H = 0x45,//R
GYRO_YOUT_L = 0x46,//R
GYRO_ZOUT_H = 0x47,//R
GYRO_ZOUT_L = 0x48,//R
EXT_SENS_DATA_00 = 0x49,//R
EXT_SENS_DATA_01 = 0x4A,//R
EXT_SENS_DATA_02 = 0x4B,//R
EXT_SENS_DATA_03 = 0x4C,//R
EXT_SENS_DATA_04 = 0x4D,//R
EXT_SENS_DATA_05 = 0x4E,//R
EXT_SENS_DATA_06 = 0x4F,//R
EXT_SENS_DATA_07 = 0x50,//R
EXT_SENS_DATA_08 = 0x51,//R
EXT_SENS_DATA_09 = 0x52,//R
EXT_SENS_DATA_10 = 0x53,//R
EXT_SENS_DATA_11 = 0x54,//R
EXT_SENS_DATA_12 = 0x55,//R
EXT_SENS_DATA_13 = 0x56,//R
EXT_SENS_DATA_14 = 0x57,//R
EXT_SENS_DATA_15 = 0x58,//R
EXT_SENS_DATA_16 = 0x59,//R
EXT_SENS_DATA_17 = 0x5A,//R
EXT_SENS_DATA_18 = 0x5B,//R
EXT_SENS_DATA_19 = 0x5C,//R
EXT_SENS_DATA_20 = 0x5D,//R
EXT_SENS_DATA_21 = 0x5E,//R
EXT_SENS_DATA_22 = 0x5F,//R
EXT_SENS_DATA_23 = 0x60,//R
I2C_SLV0_DO = 0x63,//R/W
I2C_SLV1_DO = 0x64,//R/W
I2C_SLV2_DO = 0x65,//R/W
I2C_SLV3_DO = 0x66,//R/W
I2C_MST_DELAY_CTRL = 0x67,//R/W
SIGNAL_PATH_RESET = 0x68,//R/W
MOT_DETECT_CTRL = 0x69,//R/W
USER_CTRL = 0x6A,//R/W
PWR_MGMT_1 = 0x6B,//R/W
PWR_MGMT_2 = 0x6C,//R/W
FIFO_COUNTH = 0x72,//R/W
FIFO_COUNTL = 0x73,//R/W
FIFO_R_W = 0x74,//R/W
WHO_AM_I = 0x75,//R
XA_OFFSET_H = 0x77,//R/W
XA_OFFSET_L = 0x78,//R/W
YA_OFFSET_H = 0x7A,//R/W
YA_OFFSET_L = 0x7B,//R/W
ZA_OFFSET_H = 0x7D,//R/W
ZA_OFFSET_L = 0x7E,//R/W
};
enum class ak8963_RegMap : uint8_t {
//Magnetometer register maps
WIA = 0x00,
INFO = 0x01,
ST1 = 0x02,
XOUT_L = 0x03,
XOUT_H = 0x04,
YOUT_L = 0x05,
YOUT_H = 0x06,
ZOUT_L = 0x07,
ZOUT_H = 0x08,
ST2 = 0x09,
CNTL = 0x0A,
CNTL2 = 0x0B,
RSV = 0x0B, //DO NOT ACCESS <MPU9250_AK8963_CNTL2>
ASTC = 0x0C,
TS1 = 0x0D, //DO NOT ACCESS
TS2 = 0x0E, //DO NOT ACCESS
I2CDIS = 0x0F,
ASAX = 0x10,
ASAY = 0x11,
ASAZ = 0x12,
};
}
#endif // ! HITSIC_USE_DRV_IMU_INV
#endif //UTILITIES_DRV_IMU_INVENSENSE_DEF_HPP | 30.846395 | 75 | 0.617378 | JerrySkywalker |
b45b664660b3cd0a2319cf5c7c4a09eb52d88aae | 751 | hpp | C++ | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | 23 | 2015-05-28T06:51:30.000Z | 2021-10-11T07:40:05.000Z | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | null | null | null | util/common.hpp | gballard/fast-matmul | 7fc50cdaa48e3844cef4e05f48cce7cf73b43756 | [
"BSD-2-Clause"
] | 18 | 2015-07-25T16:49:35.000Z | 2021-11-18T15:59:48.000Z | /**
Copyright (c) 2014-2015, Sandia Corporation
All rights reserved.
This file is part of fast-matmul and is under the BSD 2-Clause License,
which can be found in the LICENSE file in the root directory, or at
http://opensource.org/licenses/BSD-2-Clause.
*/
#ifndef _COMMON_HPP_
#define _COMMON_HPP_
#define _DFS_PAR_ 1
#define _BFS_PAR_ 2
#define _HYBRID_PAR_ 3
#include "MemoryManager.hpp"
#include "linalg.hpp"
#ifdef _PARALLEL_
# include "omp.h"
#endif
#include "par_util.hpp"
#include "options.hpp"
#include "timing.hpp"
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T>& vec) {
for (int i = 0; i < vec.size(); ++i) {
os << vec[i] << " ";
}
os << std::endl;
}
#endif // _COMMON_HPP_
| 19.763158 | 75 | 0.683089 | gballard |
Subsets and Splits