blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
38e8b9456c8d566480d1316da0410549479cddd6 | 1df608097eadfb675c805b0ce8bbbbcd15b11a3d | /data_testing/test_macros.hpp | c8ccde694c38017b866608b2cefcb3f31665eedc | [] | no_license | sabjohnso/data | 53afaf47944eff7a54f2b2f8192b3ba600fa6af6 | fdf1b48f95672bf172e79af4e79859c78d4f5791 | refs/heads/master | 2020-03-22T01:59:37.988432 | 2018-07-01T15:55:53 | 2018-07-01T15:55:53 | 139,343,139 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,740 | hpp | #ifndef TEST_MACROS_HPP_INCLUDED_1448200748401194703
#define TEST_MACROS_HPP_INCLUDED_1448200748401194703 1
//
// ... Standard header files
//
#include <iostream>
#define DATA_TEST_PRINT_AUX( ... ) #__VA_ARGS__
#define DATA_TEST_PRINT( ... ) DATA_TEST_PRINT_AUX( __VA_ARGS__ )
#define DATA_FAIL( accum, ... ) \
{ \
++accum; \
std::cout << "\n" << __FILE__ << ':' << __LINE__ << ":0" \
<< " DATA test failure\n" \
<< DATA_TEST_PRINT( __VA_ARGS__ ) << '\n' \
<< " did not evaluate to true.\n\n"; \
}
#define DATA_PASS( ... ) \
{ \
std::cout << '.'; \
}
/** The first argument to a test is a variable
that is accumulating the count of test failures,
and the rest are an expression that evaluates
to true to pass or false to fail. Upon failure,
a message is printed with the location of the
failure. Upon success, a '.' is printed to
indicate the successfull execution. */
#define DATA_TEST( accum , ... ) \
if(!( __VA_ARGS__ )){ \
DATA_FAIL( accum, __VA_ARGS__ ); \
} \
else{ \
DATA_PASS( __VA_ARGS___ ); \
}
/** Static tests use static_assert and are really only executed
at compile time. At runtime, a '+' is printed to indicate
the static test passed, but it was not actually executed at
runtime.
*/
#define DATA_STATIC_TEST( ... ) \
{ \
static_assert( __VA_ARGS__, "DATA static test failure" ); \
std::cout << '+'; \
}
/** Don't run the test, just print a ? to idicated that
the test is pending.
*/
#define DATA_PENDING_TEST( ... ) \
{ \
std::cout << '?'; \
}
#endif // !defined TEST_MACROS_HPP_INCLUDED_1448200748401194703
| [
"[email protected]"
] | |
1d22ff1a83afd740fc0ea6809d870edd43854d67 | c08c76c06d3e48f2ce2493e22fca4f1f82839cbd | /10.8.8_ST_substr_position.cpp | 40079bc16bee169866da9fc741a8a4d6de876f82 | [] | no_license | fredeom/shen_book_solutions | 1d5ba1ce1d731849afaf7a08b679dfe76c6a0804 | a8396b1ffaaaf2696fd980504e7ec18f4d096646 | refs/heads/master | 2022-11-09T19:11:49.794742 | 2020-07-03T16:36:55 | 2020-07-03T16:36:55 | 275,020,209 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,615 | cpp | //
//
// Remake of https://e-maxx.ru/algo/ukkonen
//
//
#include <iostream>
#include <vector>
#include <map>
using namespace std;
const int inf = 1e9;
int COUNT = 0;
struct Node {
int l, r, id;
map<int, Node*> t;
Node *s;
Node *p;
Node(int l1 = -1, int r1 = -1): l(l1), r(r1), id(COUNT++) {};
void draw(string s1) {
cout << "[";
// cout << id << " ";
if (l >= 0 && r >= 0) {
cout << s1.substr(l, r - l + 1);
}
cout << "]";
cout << "(";
for (int i = 0; i < 256; ++i)
if (t.count(i)) {
t[i]->draw(s1);
cout << ",";
}
cout << ")";
}
};
int main() {
string s, s2;
freopen("10.8.8.in", "r", stdin);
cin >> s >> s2;
Node * node = new Node, *root = node, *nc, *split = 0, *fake_node = new Node;
for (int i = 0; i < 256; i++) fake_node->t[i] = node;
node->s = fake_node;
int curr = 0;
for (int i = 0; i < s.length(); ++i) {
char c = s[i];
while (true) {
if (node->r < curr) {
if (!node->t[c]) {
Node * ts = new Node;
node->t[c] = ts;
ts->l = i;
ts->r = s.length() - 1;
ts->p = node;
if (node->s) node = node->s; else node = root;
curr = node->r + 1;
continue;
}
node = node->t[c];
curr = node->l;
}
if (curr == -1 || c == s[curr]) {
curr++;
break;
}
if (!split) split = new Node;
nc = new Node;
nc->l = i;
nc->r = s.length() - 1;
nc->p = split;
split->l = node->l;
split->r = curr - 1;
split->p = node->p;
split->t[c] = nc;
split->t[s[curr]] = node;
node->l = curr;
node->p = split;
split->p->t[s[split->l]] = split;
node = split->p->s;
curr = split->l;
while (curr <= split->r) {
node = node->t[s[curr]];
curr += node->r - node->l + 1;
}
int splitr = split->r;
if (curr == splitr + 1) {
split->s = node;
split = 0;
} else {
split->s = new Node;
split = split->s;
}
curr = node->r - (curr - splitr) + 2;
}
}
//root->draw(s); cout << endl;
node = root;
int p = 0;
for (char ch : s2) {
if (p < node->r) {
p++;
} else {
if (node->t[ch]) {
node = node->t[ch];
p = node->l;
} else {
p = -1;
break;
}
}
}
if (p >= 0) {
cout << "Found on " << p - s2.length() + 1 << " " << s.substr(p - s2.length() + 1, s2.length()) << endl;
} else {
cout << "Not found" << endl;
}
return 0;
}
| [
"[email protected]"
] | |
7cb9a6a276b18187c20ec4efe0df378245be7415 | bd226417f1cc508a6fdadf8c996552184e89b34e | /competitive_coding/contests/Codechef/RE.Code2020/C.cpp | a555c1fb018a69db5562a1b25eddee1d5c7f027d | [
"MIT"
] | permissive | rupav/cp | 5876a42f5d86df482426b523fdeddcd84843c373 | 0b4c20ef3504472c1b0a9bbf586bb2daae9631c5 | refs/heads/main | 2023-02-24T23:21:31.930979 | 2021-01-30T06:08:15 | 2021-01-30T06:08:15 | 334,339,922 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 978 | cpp | #include<bits/stdc++.h>
using namespace std;
#define watch(x) cout << (#x) << " is " << (x) << endl
#define fr(i,n) for(int i=0; i<n; i++)
#define rep(i, st, en) for(int i=st; i<=en; i++)
#define repn(i, st, en) for(int i=st; i>=en; i--)
#define sq(a) (a*a)
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll mod = 1e9+7;
/// https://www.codechef.com/RC122020/problems/RECNDSTR
bool solve(){
string s;
int n;
cin>>s;
n = s.size();
if(n == 1) return true;
map<char, int> mp[2];
fr(i, n) mp[i&1][s[i]]++;
if(mp[0].size() > 1 || mp[1].size() > 1) return false;
if(n & 1){
/// all must be equal
return (mp[0].begin()->first == mp[1].begin()->first);
} else
return true; /// even case
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t = 1;
cin>>t;
while(t--){
cout<<(solve() ? "YES" : "NO")<<endl;
}
return 0;
}
| [
"[email protected]"
] | |
921f38ecc74c3f567d0f288bc11ef1ea95743d65 | ced0e9a69b30a7c4492291af41ed70d380410c76 | /FIT2049 - Week 3 Solution/EnemyKart.cpp | a1d1d27c100b000ff4d05b93cc560fc2113f0d19 | [] | no_license | mattskel/FIT2049Assignment2 | 38d89b481fb6a9b107504fd168322e6392336f66 | 714ff6db2fef3ef465c31f0379a15b87bed3a005 | refs/heads/master | 2020-04-23T21:12:57.255309 | 2016-09-23T08:24:01 | 2016-09-23T08:24:01 | 67,715,082 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,458 | cpp | #include "EnemyKart.h"
#include "MathsHelper.h"
#include <iostream>
EnemyKart::EnemyKart(Mesh* mesh,
Shader* shader,
Texture* texture,
Vector3 position,
int flag) :
Kart(mesh,shader,texture,position,NULL) {
m_moveSpeed = 3.0f; // Alter these to change the speed
m_turnSpeed = 2.0f; // Alter turn speed
m_frictionAmount = 4.0f;
m_boundingBox = CBoundingBox(GetPosition() + m_mesh->GetMin(),
GetPosition() + m_mesh->GetMax());
// Checks what kind of EnemyKart it is
if (flag == 0) {
m_chasingPlayer = false;
m_targetPosition = GetRandomPosition();
}
else {
m_chasingPlayer = true;
}
m_targetIsItemBox = false;
m_previousItemBox = NULL;
}
void EnemyKart::Update(float timestep) {
// Check for an item
// Release if it exists
if (m_itemValue >= 0) {
ItemReleased();
}
// The chasing karts need to be able to pick up items too
// IF statement to prevent chasing kart from always following the player
if (m_chasingPlayer && !m_targetIsItemBox) {
m_targetPosition = m_playerKart->GetPosition();
}
// Once the kart is close enough to the target position, a new position is generated
if (Vector3::DistanceSquared(GetPosition(), m_targetPosition) <= 5.0f) {
if (!m_chasingPlayer) {
m_targetPosition = GetRandomPosition();
m_startNewTarget = time(NULL);
}
m_targetIsItemBox = false;
}
// Checks how long EnemyKart has been chasing a target
// If exceeds the predefined time, generate a new target
// This is to prevent Karts getting stuck in circles
else if (time(NULL) - m_startNewTarget > 20 && !m_chasingPlayer) {
m_targetPosition = GetRandomPosition();
m_startNewTarget = time(NULL);
}
else {
// First check if there are any item boxes near by
// If there are then we will reset m_targetPosition
// Only check if we are not already looking for an ItemBox
float maxDist = 50.0f; // We are looking for an item box less than 50.f away
float minDist = 20.0f;
if (!m_targetIsItemBox) {
for (ItemBox* itemBox : *m_itemBoxes) {
// Check we are not returning to Item Box just visited
if (itemBox != m_previousItemBox) {
Vector3 itemBoxPosition = itemBox->GetPosition();
Vector3 itemBoxVector = itemBoxPosition - GetPosition();
//Get the vector length
float vectorLength = itemBoxVector.Length();
// Only if the item box is nearby reset m_targetPosition
// Also check it is greater than a min dist
// This is to prevent always returning to the same item box
if (vectorLength < maxDist && vectorLength > minDist) {
maxDist = vectorLength;
m_targetPosition = itemBoxPosition;
m_previousItemBox = itemBox;
}
}
}
}
// maxDist has been reset
// Must have found an item box
if (maxDist < 50.0f) {
m_targetIsItemBox = true;
}
Vector3 worldForward = Vector3(0, 0, 1);
Matrix heading = Matrix::CreateRotationY(m_rotY);
Vector3 localForward = Vector3::TransformNormal(worldForward, heading);
// A vector from current position to target position
Vector3 targetVector = m_targetPosition - GetPosition();
// Normalise the vector
// Get the vector length
float vectorLength = targetVector.Length();
Vector3 normalTargetVector = Vector3(targetVector.x / vectorLength,
targetVector.y / vectorLength,
targetVector.z / vectorLength);
// Use the cross product to determine what direction to turn
float crossProduct = localForward.x * normalTargetVector.z - localForward.z*normalTargetVector.x;
// Use the sign of the cross product to turn left or right
if (crossProduct > 0.01f) {
m_rotY -= m_turnSpeed * timestep;
}
else if (crossProduct < -0.01f) {
m_rotY += m_turnSpeed * timestep;
}
// Apply the force in the forward direction
ApplyForce(localForward * m_moveSpeed * timestep);
}
// Check if the EnemyKart has invincibility
if (m_invincible) {
if (time(NULL) - m_invincibleStart > 5) {
m_moveSpeed = 4.0f;
m_invincible = false;
}
}
// Move collider
m_boundingBox.SetMin(GetPosition() + m_mesh->GetMin());
m_boundingBox.SetMax(GetPosition() + m_mesh->GetMax());
PhysicsObject::Update(timestep);
// If all lives are gone set the status to 0
if (m_livesRemaining == 0) {
m_status = 0;
}
}
// Generates a random position in the playing area
Vector3 EnemyKart::GetRandomPosition() {
return Vector3(MathsHelper::RandomRange(-WORLD_WIDTH, WORLD_WIDTH),0,
MathsHelper::RandomRange(-WORLD_DEPTH, WORLD_DEPTH));
} | [
"[email protected]"
] | |
f339429e024027c3fa880156bb0ad77605925060 | e104df78ab10c424b52c3cc37e6e5e7572a00d1e | /3rdparty/OpenGL/include/Simd/SimdSse1Winograd.cpp | 642fce2ec68f0993139ed59d5cf054e0df0ec949 | [] | no_license | jsyang2207/ImageEvaluate | f50edc00b938f4ad9bd46e0cc68bc13b922f1600 | 59755d38fe48e169f2a02fca4e6f1929a8e5be6d | refs/heads/master | 2022-12-02T18:06:26.090997 | 2020-08-19T05:25:54 | 2020-08-19T05:25:54 | 288,387,109 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 156,591 | cpp | /*
* Simd Library (http://ermig1979.github.io/Simd).
*
* Copyright (c) 2011-2020 Yermalayeu Ihar.
*
* 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 "Simd/SimdMemory.h"
#include "Simd/SimdStore.h"
#include "Simd/SimdWinograd.h"
#include "Simd/SimdBase.h"
namespace Simd
{
#ifdef SIMD_SSE_ENABLE
namespace Sse
{
SIMD_INLINE void Load4(const float * src, size_t step, __m128 * dst)
{
__m128 a0 = _mm_loadu_ps(src + 0 * step);
__m128 a1 = _mm_loadu_ps(src + 1 * step);
__m128 a2 = _mm_loadu_ps(src + 2 * step);
__m128 a3 = _mm_loadu_ps(src + 3 * step);
__m128 b0 = _mm_unpacklo_ps(a0, a2);
__m128 b1 = _mm_unpackhi_ps(a0, a2);
__m128 b2 = _mm_unpacklo_ps(a1, a3);
__m128 b3 = _mm_unpackhi_ps(a1, a3);
dst[0] = _mm_unpacklo_ps(b0, b2);
dst[1] = _mm_unpackhi_ps(b0, b2);
dst[2] = _mm_unpacklo_ps(b1, b3);
dst[3] = _mm_unpackhi_ps(b1, b3);
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x3Block1x4SetFilter(const __m128 * t, float* dst, size_t stride)
{
const __m128 r4 = _mm_set1_ps(1.0f / 4.0f);
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 mr6 = _mm_set1_ps(-1.0f / 6.0f);
const __m128 r12 = _mm_set1_ps(1.0f / 12.0f);
const __m128 r24 = _mm_set1_ps(1.0f / 24.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_mul_ps(r4, t[0]));
__m128 t0 = _mm_add_ps(t[0], t[2]);
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(mr6, _mm_add_ps(t0, t[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(mr6, _mm_sub_ps(t0, t[1])));
__m128 t1 = _mm_add_ps(_mm_mul_ps(r24, t[0]), _mm_mul_ps(r6, t[2]));
__m128 t2 = _mm_mul_ps(r12, t[1]);
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(t1, t2));
_mm_storeu_ps(dst + 4 * stride, _mm_sub_ps(t1, t2));
_mm_storeu_ps(dst + 5 * stride, t[2]);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetFilter4n(const float* src, float* dst, size_t stride)
{
__m128 s[3];
s[0] = _mm_setr_ps(src[0], src[3], src[6], src[9]);
s[1] = _mm_setr_ps(src[1], src[4], src[7], src[10]);
s[2] = _mm_setr_ps(src[2], src[5], src[8], src[11]);
WinogradKernel1x3Block1x4SetFilter(s, dst, stride);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetFilter4t(const float* src, float* dst, size_t stride)
{
__m128 s[3];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
WinogradKernel1x3Block1x4SetFilter(s, dst, stride);
}
void WinogradKernel1x3Block1x4SetFilter(const float* src, size_t size, float* dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel1x3Block1x4SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel1x3Block1x4SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 12, dst += 4)
WinogradKernel1x3Block1x4SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 3, dst += 1)
Base::WinogradKernel1x3Block1x4SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x3Block1x4SetInput4Store(const __m128 src[6], float* dst, size_t stride)
{
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 _5 = _mm_set1_ps(5.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[0]), _mm_mul_ps(_5, src[2])), src[4]));
_mm_storeu_ps(dst + 1 * stride, _mm_sub_ps(_mm_add_ps(src[3], src[4]), _mm_mul_ps(_4, _mm_add_ps(src[1], src[2]))));
_mm_storeu_ps(dst + 2 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[1], src[2])), _mm_sub_ps(src[4], src[3])));
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[3], src[1])), _mm_sub_ps(src[4], src[2])));
_mm_storeu_ps(dst + 4 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[1], src[3])), _mm_sub_ps(src[4], src[2])));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[1]), _mm_mul_ps(_5, src[3])), src[5]));
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetInput4t(const float* src, size_t srcC, __m128 dst[6])
{
dst[0] = _mm_loadu_ps(src + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 4 * srcC);
dst[5] = _mm_loadu_ps(src + 5 * srcC);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetInput4t(const float* src, size_t srcC, float* dst, size_t dstStride)
{
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[6];
WinogradKernel1x3Block1x4SetInput4t(src + c, srcC, tmp);
WinogradKernel1x3Block1x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[6];
WinogradKernel1x3Block1x4SetInput4t(src + srcC - F, srcC, tmp);
WinogradKernel1x3Block1x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetInput4t(const float* src, size_t srcC, size_t colB, size_t colE, __m128 dst[6])
{
for (size_t col = 0; col < colB; ++col)
dst[col] = _mm_setzero_ps();
for (size_t col = colB; col < colE; ++col)
dst[col] = _mm_loadu_ps(src + col * srcC);
for (size_t col = colE; col < 6; ++col)
dst[col] = _mm_setzero_ps();
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetInput4t(const float* src, size_t srcC, size_t colB, size_t colE, float* dst, size_t dstStride)
{
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[6];
WinogradKernel1x3Block1x4SetInput4t(src + c, srcC, colB, colE, tmp);
WinogradKernel1x3Block1x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[6];
WinogradKernel1x3Block1x4SetInput4t(src + srcC - F, srcC, colB, colE, tmp);
WinogradKernel1x3Block1x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel1x3Block1x4SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padX == padW && padY == 0 && padH == 0 && (padX == 0 || padX == 1));
if (trans ? (srcChannels < 4) : (srcWidth < 12))
{
Base::WinogradKernel1x3Block1x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = srcHeight;
size_t dstW = padX ? srcWidth : srcWidth - 2;
size_t tileW = (dstW + 3) / 4;
size_t dstW4 = AlignLo(dstW, 4);
if (trans)
{
size_t noseW = Simd::Min<size_t>(6, dstW + 1);
size_t startX = padX ? 4 : 0;
if (padX)
{
if (dstW == dstW4)
dstW4 -= 4;
src -= srcChannels;
}
size_t tailW = dstW - dstW4 + (padX ? 1 : 2);
for (size_t row = 0; row < dstH; row += 1)
{
size_t col = 0;
if (padX)
WinogradKernel1x3Block1x4SetInput4t(src, srcChannels, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel1x3Block1x4SetInput4t(src + col * srcChannels, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel1x3Block1x4SetInput4t(src + col * srcChannels, srcChannels, 0, tailW, dst, dstStride), dst += srcChannels;
src += srcWidth * srcChannels;
}
}
else
{
Base::WinogradKernel1x3Block1x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x3Block1x4SetOutputLoad6(const float* src, size_t stride, __m128 dst[4])
{
__m128 s[6];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 _8 = _mm_set1_ps(8.0f);
dst[0] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[0], s[1]), _mm_add_ps(s[2], s[3])), s[4]);
dst[1] = _mm_add_ps(_mm_sub_ps(s[1], s[2]), _mm_mul_ps(_2, _mm_sub_ps(s[3], s[4])));
dst[2] = _mm_add_ps(_mm_add_ps(s[1], s[2]), _mm_mul_ps(_4, _mm_add_ps(s[3], s[4])));
dst[3] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[1], s[2]), _mm_mul_ps(_8, _mm_sub_ps(s[3], s[4]))), s[5]);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetOutputStore4(const __m128 src[4], float* dst, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 2 * dstC, src[2]);
_mm_storeu_ps(dst + 3 * dstC, src[3]);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstC)
{
size_t dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel1x3Block1x4SetOutputLoad6(src + d, srcStride, tmp);
WinogradKernel1x3Block1x4SetOutputStore4(tmp, dst + d, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel1x3Block1x4SetOutputLoad6(src + dstC - F, srcStride, tmp);
WinogradKernel1x3Block1x4SetOutputStore4(tmp, dst + dstC - F, dstC);
}
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetOutputStore4(const __m128 src[4], float* dst, size_t dstC, size_t colE)
{
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + col * dstC, src[col]);
}
SIMD_INLINE void WinogradKernel1x3Block1x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstC, size_t colE)
{
size_t dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel1x3Block1x4SetOutputLoad6(src + d, srcStride, tmp);
WinogradKernel1x3Block1x4SetOutputStore4(tmp, dst + d, dstC, colE);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel1x3Block1x4SetOutputLoad6(src + dstC - F, srcStride, tmp);
WinogradKernel1x3Block1x4SetOutputStore4(tmp, dst + dstC - F, dstC, colE);
}
}
void WinogradKernel1x3Block1x4SetOutput(const float* src, size_t srcStride, float* dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < 4) : (dstWidth < 16))
{
Base::WinogradKernel1x3Block1x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileW = (dstWidth + 3) / 4;
size_t dstW4 = AlignLo(dstWidth, 4);
if (trans)
{
for (size_t row = 0; row < dstHeight; row += 1)
{
size_t col;
for (col = 0; col < dstW4; col += 4)
WinogradKernel1x3Block1x4SetOutput4t(src, srcStride, dst + col * dstChannels, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel1x3Block1x4SetOutput4t(src, srcStride, dst + col * dstChannels, dstChannels, dstWidth - col), src += dstChannels;
dst += dstWidth * dstChannels;
}
}
else
{
Base::WinogradKernel1x3Block1x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x5Block1x4SetFilter(const __m128 * t, float* dst, size_t stride)
{
const __m128 r36 = _mm_set1_ps(1.0f / 36.0f);
const __m128 r48 = _mm_set1_ps(1.0f / 48.0f);
const __m128 mr120 = _mm_set1_ps(-1.0f / 120.0f);
const __m128 r720 = _mm_set1_ps(1.0f / 720.0f);
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _3 = _mm_set1_ps(3.0f);
const __m128 _4 = _mm_set1_ps(4.0f);
const __m128 _9 = _mm_set1_ps(9.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_mul_ps(r36, t[0]));
__m128 a[2];
a[0] = _mm_add_ps(_mm_add_ps(t[0], t[2]), t[4]);
a[1] = _mm_add_ps(t[1], t[3]);
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(r48, _mm_add_ps(a[0], a[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(r48, _mm_sub_ps(a[0], a[1])));
a[0] = _mm_add_ps(t[0], _mm_mul_ps(_4, _mm_add_ps(t[2], _mm_mul_ps(_4, t[4]))));
a[1] = _mm_mul_ps(_2, _mm_add_ps(t[1], _mm_mul_ps(_4, t[3])));
_mm_storeu_ps(dst + 3 * stride, _mm_mul_ps(mr120, _mm_add_ps(a[0], a[1])));
_mm_storeu_ps(dst + 4 * stride, _mm_mul_ps(mr120, _mm_sub_ps(a[0], a[1])));
a[0] = _mm_add_ps(t[0], _mm_mul_ps(_9, _mm_add_ps(t[2], _mm_mul_ps(_9, t[4]))));
a[1] = _mm_mul_ps(_3, _mm_add_ps(t[1], _mm_mul_ps(_9, t[3])));
_mm_storeu_ps(dst + 5 * stride, _mm_mul_ps(r720, _mm_add_ps(a[0], a[1])));
_mm_storeu_ps(dst + 6 * stride, _mm_mul_ps(r720, _mm_sub_ps(a[0], a[1])));
_mm_storeu_ps(dst + 7 * stride, t[4]);
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetFilter4n(const float* src, float* dst, size_t stride)
{
__m128 s[5];
Load4(src + 0, 5, s + 0);
s[4] = _mm_setr_ps(src[4], src[9], src[14], src[19]);
WinogradKernel1x5Block1x4SetFilter(s, dst, stride);
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetFilter4t(const float* src, float* dst, size_t stride)
{
__m128 s[5];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
WinogradKernel1x5Block1x4SetFilter(s, dst, stride);
}
void WinogradKernel1x5Block1x4SetFilter(const float* src, size_t size, float* dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel1x5Block1x4SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel1x5Block1x4SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 20, dst += 4)
WinogradKernel1x5Block1x4SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 5, dst += 1)
Base::WinogradKernel1x5Block1x4SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x5Block1x4SetInput4Store(const __m128 src[8], float* dst, size_t stride)
{
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _3 = _mm_set1_ps(3.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 _5 = _mm_set1_ps(5.0f);
__m128 _9 = _mm_set1_ps(9.0f);
__m128 _10 = _mm_set1_ps(10.0f);
__m128 _13 = _mm_set1_ps(13.0f);
__m128 _14 = _mm_set1_ps(14.0f);
__m128 _36 = _mm_set1_ps(36.0f);
__m128 _49 = _mm_set1_ps(49.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_36, src[0]), _mm_mul_ps(_49, src[2])), _mm_sub_ps(_mm_mul_ps(_14, src[4]), src[6])));
__m128 a[2];
a[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_36, src[2]), _mm_mul_ps(_13, src[4])), src[6]);
a[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_36, src[1]), _mm_mul_ps(_13, src[3])), src[5]);
_mm_storeu_ps(dst + 1 * stride, _mm_add_ps(a[0], a[1]));
_mm_storeu_ps(dst + 2 * stride, _mm_sub_ps(a[0], a[1]));
a[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_9, src[2]), _mm_mul_ps(_10, src[4])), src[6]);
a[1] = _mm_mul_ps(_2, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_9, src[1]), _mm_mul_ps(_10, src[3])), src[5]));
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(a[0], a[1]));
_mm_storeu_ps(dst + 4 * stride, _mm_sub_ps(a[0], a[1]));
a[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[2]), _mm_mul_ps(_5, src[4])), src[6]);
a[1] = _mm_mul_ps(_3, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[1]), _mm_mul_ps(_5, src[3])), src[5]));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(a[0], a[1]));
_mm_storeu_ps(dst + 6 * stride, _mm_sub_ps(a[0], a[1]));
_mm_storeu_ps(dst + 7 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_49, src[3]), _mm_mul_ps(_36, src[1])), _mm_sub_ps(src[7], _mm_mul_ps(_14, src[5]))));
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetInput4t(const float* src, size_t srcC, __m128 dst[8])
{
dst[0] = _mm_loadu_ps(src + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 4 * srcC);
dst[5] = _mm_loadu_ps(src + 5 * srcC);
dst[6] = _mm_loadu_ps(src + 6 * srcC);
dst[7] = _mm_loadu_ps(src + 7 * srcC);
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetInput4t(const float* src, size_t srcC, float* dst, size_t dstStride)
{
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[8];
WinogradKernel1x5Block1x4SetInput4t(src + c, srcC, tmp);
WinogradKernel1x5Block1x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[8];
WinogradKernel1x5Block1x4SetInput4t(src + srcC - F, srcC, tmp);
WinogradKernel1x5Block1x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetInput4t(const float* src, size_t srcC, size_t colB, size_t colE, __m128 dst[8])
{
for (size_t col = 0; col < colB; ++col)
dst[col] = _mm_setzero_ps();
for (size_t col = colB; col < colE; ++col)
dst[col] = _mm_loadu_ps(src + col * srcC);
for (size_t col = colE; col < 8; ++col)
dst[col] = _mm_setzero_ps();
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetInput4t(const float* src, size_t srcC, size_t colB, size_t colE, float* dst, size_t dstStride)
{
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[8];
WinogradKernel1x5Block1x4SetInput4t(src + c, srcC, colB, colE, tmp);
WinogradKernel1x5Block1x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[8];
WinogradKernel1x5Block1x4SetInput4t(src + srcC - F, srcC, colB, colE, tmp);
WinogradKernel1x5Block1x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel1x5Block1x4SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padX == padW && padY == 0 && padH == 0 && (padX == 0 || padX == 2));
if (trans ? (srcChannels < F) : true)
{
Base::WinogradKernel1x5Block1x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = srcHeight;
size_t dstW = padX ? srcWidth : srcWidth - 4;
size_t tileW = (dstW + 3) / 4;
size_t dstW4 = AlignLo(dstW, 4);
size_t noseW = Simd::Min<size_t>(8, dstW + 2);
size_t startX = padX ? 4 : 0;
if (padX)
{
if (dstW == dstW4 || dstW == dstW4 + 1)
dstW4 -= 4;
src -= 2*srcChannels;
}
size_t tailW = dstW - dstW4 + (padX ? 2 : 4);
for (size_t row = 0; row < dstH; row += 1)
{
size_t col = 0;
if (padX)
WinogradKernel1x5Block1x4SetInput4t(src, srcChannels, 2, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel1x5Block1x4SetInput4t(src + col * srcChannels, srcChannels, dst, dstStride), dst += srcChannels;
for (size_t tail = tailW; col < dstW; col += 4, tail -= 4)
WinogradKernel1x5Block1x4SetInput4t(src + col * srcChannels, srcChannels, 0, tail, dst, dstStride), dst += srcChannels;
src += srcWidth * srcChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel1x5Block1x4SetOutputLoad8(const float* src, size_t stride, __m128 dst[4])
{
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _3 = _mm_set1_ps(3.0f);
const __m128 _4 = _mm_set1_ps(4.0f);
const __m128 _9 = _mm_set1_ps(9.0f);
__m128 s[8];
s[0] = _mm_loadu_ps(src + 1 * stride);
s[7] = _mm_loadu_ps(src + 2 * stride);
s[1] = _mm_add_ps(s[0], s[7]);
s[2] = _mm_sub_ps(s[0], s[7]);
s[0] = _mm_loadu_ps(src + 3 * stride);
s[7] = _mm_loadu_ps(src + 4 * stride);
s[3] = _mm_add_ps(s[0], s[7]);
s[4] = _mm_mul_ps(_2, _mm_sub_ps(s[0], s[7]));
s[0] = _mm_loadu_ps(src + 5 * stride);
s[7] = _mm_loadu_ps(src + 6 * stride);
s[5] = _mm_add_ps(s[0], s[7]);
s[6] = _mm_mul_ps(_3, _mm_sub_ps(s[0], s[7]));
dst[0] = _mm_add_ps(_mm_loadu_ps(src + 0 * stride), _mm_add_ps(_mm_add_ps(s[1], s[3]), s[5]));
dst[1] = _mm_add_ps(s[2], _mm_add_ps(s[4], s[6]));
dst[2] = _mm_add_ps(s[1], _mm_add_ps(_mm_mul_ps(_4, s[3]), _mm_mul_ps(_9, s[5])));
dst[3] = _mm_add_ps(_mm_loadu_ps(src + 7 * stride), _mm_add_ps(_mm_add_ps(s[2], _mm_mul_ps(_4, s[4])), _mm_mul_ps(_9, s[6])));
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetOutputStore4(const __m128 src[4], float* dst, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 2 * dstC, src[2]);
_mm_storeu_ps(dst + 3 * dstC, src[3]);
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstC)
{
size_t dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel1x5Block1x4SetOutputLoad8(src + d, srcStride, tmp);
WinogradKernel1x5Block1x4SetOutputStore4(tmp, dst + d, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel1x5Block1x4SetOutputLoad8(src + dstC - F, srcStride, tmp);
WinogradKernel1x5Block1x4SetOutputStore4(tmp, dst + dstC - F, dstC);
}
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetOutputStore4(const __m128 src[4], float* dst, size_t dstC, size_t colE)
{
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + col * dstC, src[col]);
}
SIMD_INLINE void WinogradKernel1x5Block1x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstC, size_t colE)
{
size_t dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel1x5Block1x4SetOutputLoad8(src + d, srcStride, tmp);
WinogradKernel1x5Block1x4SetOutputStore4(tmp, dst + d, dstC, colE);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel1x5Block1x4SetOutputLoad8(src + dstC - F, srcStride, tmp);
WinogradKernel1x5Block1x4SetOutputStore4(tmp, dst + dstC - F, dstC, colE);
}
}
void WinogradKernel1x5Block1x4SetOutput(const float* src, size_t srcStride, float* dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < F) : true)
{
Base::WinogradKernel1x5Block1x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileW = (dstWidth + 3) / 4;
size_t dstW4 = AlignLo(dstWidth, 4);
for (size_t row = 0; row < dstHeight; row += 1)
{
size_t col;
for (col = 0; col < dstW4; col += 4)
WinogradKernel1x5Block1x4SetOutput4t(src, srcStride, dst + col * dstChannels, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel1x5Block1x4SetOutput4t(src, srcStride, dst + col * dstChannels, dstChannels, dstWidth - col), src += dstChannels;
dst += dstWidth * dstChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block2x2SetFilter(const __m128 src[4], float * dst, size_t stride)
{
_mm_storeu_ps(dst + 0 * stride, src[0]);
_mm_storeu_ps(dst + 1 * stride, _mm_add_ps(src[0], src[1]));
_mm_storeu_ps(dst + 2 * stride, src[1]);
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(src[0], src[2]));
_mm_storeu_ps(dst + 4 * stride, _mm_add_ps(_mm_add_ps(src[0], src[1]), _mm_add_ps(src[2], src[3])));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(src[1], src[3]));
_mm_storeu_ps(dst + 6 * stride, src[2]);
_mm_storeu_ps(dst + 7 * stride, _mm_add_ps(src[2], src[3]));
_mm_storeu_ps(dst + 8 * stride, src[3]);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetFilter4n(const float* src, float* dst, size_t stride)
{
__m128 _src[4];
Load4(src + 0, 4, _src + 0);
WinogradKernel2x2Block2x2SetFilter(_src, dst, stride);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetFilter4t(const float* src, float* dst, size_t stride)
{
__m128 _src[4];
_src[0] = _mm_loadu_ps(src + 0 * stride);
_src[1] = _mm_loadu_ps(src + 1 * stride);
_src[2] = _mm_loadu_ps(src + 2 * stride);
_src[3] = _mm_loadu_ps(src + 3 * stride);
WinogradKernel2x2Block2x2SetFilter(_src, dst, stride);
}
void WinogradKernel2x2Block2x2SetFilter(const float* src, size_t size, float* dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel2x2Block2x2SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel2x2Block2x2SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 16, dst += 4)
WinogradKernel2x2Block2x2SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 4, dst += 1)
Base::WinogradKernel2x2Block2x2SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block2x2SetInput4Store(const __m128* src, float* dst, size_t stride)
{
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_sub_ps(src[0], src[1]), _mm_sub_ps(src[4], src[3])));
_mm_storeu_ps(dst + 1 * stride, _mm_sub_ps(src[1], src[4]));
_mm_storeu_ps(dst + 2 * stride, _mm_add_ps(_mm_sub_ps(src[2], src[1]), _mm_sub_ps(src[4], src[5])));
_mm_storeu_ps(dst + 3 * stride, _mm_sub_ps(src[3], src[4]));
_mm_storeu_ps(dst + 4 * stride, src[4]);
_mm_storeu_ps(dst + 5 * stride, _mm_sub_ps(src[5], src[4]));
_mm_storeu_ps(dst + 6 * stride, _mm_add_ps(_mm_sub_ps(src[4], src[3]), _mm_sub_ps(src[6], src[7])));
_mm_storeu_ps(dst + 7 * stride, _mm_sub_ps(src[7], src[4]));
_mm_storeu_ps(dst + 8 * stride, _mm_add_ps(_mm_sub_ps(src[4], src[5]), _mm_sub_ps(src[8], src[7])));
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetInput4t(const float* src, size_t srcS, size_t srcC, __m128 dst[9])
{
dst[0] = _mm_loadu_ps(src + 0 * srcS + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 0 * srcS + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 0 * srcS + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 1 * srcS + 0 * srcC);
dst[4] = _mm_loadu_ps(src + 1 * srcS + 1 * srcC);
dst[5] = _mm_loadu_ps(src + 1 * srcS + 2 * srcC);
dst[6] = _mm_loadu_ps(src + 2 * srcS + 0 * srcC);
dst[7] = _mm_loadu_ps(src + 2 * srcS + 1 * srcC);
dst[8] = _mm_loadu_ps(src + 2 * srcS + 2 * srcC);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetInput4t(const float* src, size_t srcW, size_t srcC, float* dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[9];
WinogradKernel2x2Block2x2SetInput4t(src + c, srcS, srcC, tmp);
WinogradKernel2x2Block2x2SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[9];
WinogradKernel2x2Block2x2SetInput4t(src + srcC - F, srcS, srcC, tmp);
WinogradKernel2x2Block2x2SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetInput4t(const float* src, size_t srcS, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, __m128 dst[9])
{
for (size_t i = 0; i < 9; ++i)
dst[i] = _mm_setzero_ps();
for (size_t row = rowB; row < rowE; ++row)
for (size_t col = colB; col < colE; ++col)
dst[row * 3 + col] = _mm_loadu_ps(src + row * srcS + col * srcC);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetInput4t(const float* src, size_t srcW, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, float* dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[9];
WinogradKernel2x2Block2x2SetInput4t(src + c, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel2x2Block2x2SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[9];
WinogradKernel2x2Block2x2SetInput4t(src + srcC - F, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel2x2Block2x2SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel2x2Block2x2SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padY == padX && padW == padH && (padY + padH == 0 || padY + padH == 1));
if (trans ? (srcChannels < F) : true)
{
Base::WinogradKernel2x2Block2x2SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = srcHeight - 1 + padY + padH;
size_t dstW = srcWidth - 1 + padX + padW;
size_t dstH2 = AlignLo(dstH, 2);
size_t dstW2 = AlignLo(dstW, 2);
size_t noseW = Simd::Min<size_t>(3, dstW + 1);
size_t noseH = Simd::Min<size_t>(3, dstH + 1);
size_t startY = padY ? 2 : 0;
size_t startX = padX ? 2 : 0;
if (padY || padH)
{
if (dstH == dstH2)
dstH2 -= 2;
if (dstW == dstW2)
dstW2 -= 2;
if (padY)
src -= (srcWidth + 1) * (trans ? srcChannels : 1);
}
size_t tailW = dstW - dstW2 + (padW ? 0 : 1);
size_t tailH = dstH - dstH2 + (padH ? 0 : 1);
size_t row = 0, col = 0;
if (padY)
{
if (padX)
WinogradKernel2x2Block2x2SetInput4t(src, srcWidth, srcChannels, 1, noseH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW2; col += 2)
WinogradKernel2x2Block2x2SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, 3, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block2x2SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, tailW, dst, dstStride), dst += srcChannels;
}
for (row = startY; row < dstH2; row += 2)
{
if (padX)
WinogradKernel2x2Block2x2SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, 3, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW2; col += 2)
WinogradKernel2x2Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, 3, 0, tailW, dst, dstStride), dst += srcChannels;
}
if (row < dstH)
{
if (padX)
WinogradKernel2x2Block2x2SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, tailH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW2; col += 2)
WinogradKernel2x2Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, 3, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, tailW, dst, dstStride), dst += srcChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block2x2SetOutputLoad9(const float* src, size_t stride, __m128* dst)
{
__m128 s[9];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
dst[0] = _mm_add_ps(_mm_add_ps(s[0], s[1]), _mm_add_ps(s[3], s[4]));
dst[1] = _mm_add_ps(_mm_add_ps(s[1], s[2]), _mm_add_ps(s[4], s[5]));
dst[2] = _mm_add_ps(_mm_add_ps(s[3], s[4]), _mm_add_ps(s[6], s[7]));
dst[3] = _mm_add_ps(_mm_add_ps(s[4], s[5]), _mm_add_ps(s[7], s[8]));
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetOutputStore4(const __m128 src[4], float* dst, size_t dstS, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstS + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 0 * dstS + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 1 * dstS + 0 * dstC, src[2]);
_mm_storeu_ps(dst + 1 * dstS + 1 * dstC, src[3]);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstW, size_t dstC)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel2x2Block2x2SetOutputLoad9(src + d, srcStride, tmp);
WinogradKernel2x2Block2x2SetOutputStore4(tmp, dst + d, dstS, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel2x2Block2x2SetOutputLoad9(src + dstC - F, srcStride, tmp);
WinogradKernel2x2Block2x2SetOutputStore4(tmp, dst + dstC - F, dstS, dstC);
}
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetOutputStore4(const __m128 src[4], float* dst, size_t dstS, size_t dstC, size_t rowE, size_t colE)
{
for (size_t row = 0; row < rowE; ++row)
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + row * dstS + col * dstC, src[row * 2 + col]);
}
SIMD_INLINE void WinogradKernel2x2Block2x2SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstW, size_t dstC, size_t rowE, size_t colE)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel2x2Block2x2SetOutputLoad9(src + d, srcStride, tmp);
WinogradKernel2x2Block2x2SetOutputStore4(tmp, dst + d, dstS, dstC, rowE, colE);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel2x2Block2x2SetOutputLoad9(src + dstC - F, srcStride, tmp);
WinogradKernel2x2Block2x2SetOutputStore4(tmp, dst + dstC - F, dstS, dstC, rowE, colE);
}
}
void WinogradKernel2x2Block2x2SetOutput(const float* src, size_t srcStride, float* dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < F) : true)
{
Base::WinogradKernel2x2Block2x2SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileH = (dstHeight + 1) / 2;
size_t tileW = (dstWidth + 1) / 2;
size_t dstH2 = AlignLo(dstHeight, 2);
size_t dstW2 = AlignLo(dstWidth, 2);
size_t row, col;
for (row = 0; row < dstH2; row += 2)
{
for (col = 0; col < dstW2; col += 2)
WinogradKernel2x2Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel2x2Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, 2, dstWidth - col), src += dstChannels;
}
if (row < dstHeight)
{
for (col = 0; col < dstW2; col += 2)
WinogradKernel2x2Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, dstHeight - row, 2), src += dstChannels;
if (col < dstWidth)
WinogradKernel2x2Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, dstHeight - row, dstWidth - col), src += dstChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block4x4SetFilterRow(const __m128* t, float* dst, size_t stride)
{
const __m128 r2 = _mm_set1_ps(1.0f / 2.0f);
const __m128 r3 = _mm_set1_ps(1.0f / 3.0f);
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 mr2 = _mm_set1_ps(-1.0f / 2.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_mul_ps(r2, t[0]));
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(mr2, _mm_add_ps(t[0], t[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(r6, _mm_sub_ps(t[1], t[0])));
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(_mm_mul_ps(r6, t[0]), _mm_mul_ps(r3, t[1])));
_mm_storeu_ps(dst + 4 * stride, t[1]);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetFilter(const __m128 src[4], float* dst, size_t stride)
{
const __m128 r2 = _mm_set1_ps(1.0f / 2.0f);
const __m128 r3 = _mm_set1_ps(1.0f / 3.0f);
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 mr2 = _mm_set1_ps(-1.0f / 2.0f);
__m128 t[2];
t[0] = _mm_mul_ps(r2, src[0]);
t[1] = _mm_mul_ps(r2, src[1]);
WinogradKernel2x2Block4x4SetFilterRow(t, dst + 0 * stride, stride);
t[0] = _mm_mul_ps(mr2, _mm_add_ps(src[0], src[2]));
t[1] = _mm_mul_ps(mr2, _mm_add_ps(src[1], src[3]));
WinogradKernel2x2Block4x4SetFilterRow(t, dst + 5 * stride, stride);
t[0] = _mm_mul_ps(r6, _mm_sub_ps(src[2], src[0]));
t[1] = _mm_mul_ps(r6, _mm_sub_ps(src[3], src[1]));
WinogradKernel2x2Block4x4SetFilterRow(t, dst + 10 * stride, stride);
t[0] = _mm_add_ps(_mm_mul_ps(r6, src[0]), _mm_mul_ps(r3, src[2]));
t[1] = _mm_add_ps(_mm_mul_ps(r6, src[1]), _mm_mul_ps(r3, src[3]));
WinogradKernel2x2Block4x4SetFilterRow(t, dst + 15 * stride, stride);
t[0] = src[2];
t[1] = src[3];
WinogradKernel2x2Block4x4SetFilterRow(t, dst + 20 * stride, stride);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetFilter4n(const float* src, float* dst, size_t stride)
{
__m128 _src[4];
Load4(src + 0, 4, _src + 0);
WinogradKernel2x2Block4x4SetFilter(_src, dst, stride);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetFilter4t(const float* src, float* dst, size_t stride)
{
__m128 _src[4];
_src[0] = _mm_loadu_ps(src + 0 * stride);
_src[1] = _mm_loadu_ps(src + 1 * stride);
_src[2] = _mm_loadu_ps(src + 2 * stride);
_src[3] = _mm_loadu_ps(src + 3 * stride);
WinogradKernel2x2Block4x4SetFilter(_src, dst, stride);
}
void WinogradKernel2x2Block4x4SetFilter(const float* src, size_t size, float* dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel2x2Block4x4SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel2x2Block4x4SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 16, dst += 4)
WinogradKernel2x2Block4x4SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 4, dst += 1)
Base::WinogradKernel2x2Block4x4SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block4x4SetInputStoreRow(const __m128 tmp[5], float* dst, size_t stride)
{
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _3 = _mm_set1_ps(3.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, tmp[0]), tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_2, tmp[2]))));
_mm_storeu_ps(dst + 1 * stride, _mm_sub_ps(tmp[3], _mm_add_ps(_mm_mul_ps(_2, tmp[1]), tmp[2])));
_mm_storeu_ps(dst + 2 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, tmp[1]), _mm_mul_ps(_3, tmp[2])), tmp[3]));
_mm_storeu_ps(dst + 3 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 4 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, tmp[1]), tmp[2]), _mm_sub_ps(tmp[4], _mm_mul_ps(_2, tmp[3]))));
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetInputStore(const __m128* src, float* dst, size_t stride)
{
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _3 = _mm_set1_ps(3.0f);
__m128 tmp[5];
tmp[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[0]), src[5]), _mm_sub_ps(src[15], _mm_mul_ps(_2, src[10])));
tmp[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[1]), src[6]), _mm_sub_ps(src[16], _mm_mul_ps(_2, src[11])));
tmp[2] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[2]), src[7]), _mm_sub_ps(src[17], _mm_mul_ps(_2, src[12])));
tmp[3] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[3]), src[8]), _mm_sub_ps(src[18], _mm_mul_ps(_2, src[13])));
tmp[4] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[4]), src[9]), _mm_sub_ps(src[19], _mm_mul_ps(_2, src[14])));
WinogradKernel2x2Block4x4SetInputStoreRow(tmp, dst + 0 * stride, stride);
tmp[0] = _mm_sub_ps(src[15], _mm_add_ps(_mm_mul_ps(_2, src[5]), src[10]));
tmp[1] = _mm_sub_ps(src[16], _mm_add_ps(_mm_mul_ps(_2, src[6]), src[11]));
tmp[2] = _mm_sub_ps(src[17], _mm_add_ps(_mm_mul_ps(_2, src[7]), src[12]));
tmp[3] = _mm_sub_ps(src[18], _mm_add_ps(_mm_mul_ps(_2, src[8]), src[13]));
tmp[4] = _mm_sub_ps(src[19], _mm_add_ps(_mm_mul_ps(_2, src[9]), src[14]));
WinogradKernel2x2Block4x4SetInputStoreRow(tmp, dst + 5 * stride, stride);
tmp[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[5]), _mm_mul_ps(_3, src[10])), src[15]);
tmp[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[6]), _mm_mul_ps(_3, src[11])), src[16]);
tmp[2] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[7]), _mm_mul_ps(_3, src[12])), src[17]);
tmp[3] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[8]), _mm_mul_ps(_3, src[13])), src[18]);
tmp[4] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[9]), _mm_mul_ps(_3, src[14])), src[19]);
WinogradKernel2x2Block4x4SetInputStoreRow(tmp, dst + 10 * stride, stride);
tmp[0] = _mm_sub_ps(src[15], src[5]);
tmp[1] = _mm_sub_ps(src[16], src[6]);
tmp[2] = _mm_sub_ps(src[17], src[7]);
tmp[3] = _mm_sub_ps(src[18], src[8]);
tmp[4] = _mm_sub_ps(src[19], src[9]);
WinogradKernel2x2Block4x4SetInputStoreRow(tmp, dst + 15 * stride, stride);
tmp[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[5]), src[10]), _mm_sub_ps(src[20], _mm_mul_ps(_2, src[15])));
tmp[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[6]), src[11]), _mm_sub_ps(src[21], _mm_mul_ps(_2, src[16])));
tmp[2] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[7]), src[12]), _mm_sub_ps(src[22], _mm_mul_ps(_2, src[17])));
tmp[3] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[8]), src[13]), _mm_sub_ps(src[23], _mm_mul_ps(_2, src[18])));
tmp[4] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_2, src[9]), src[14]), _mm_sub_ps(src[24], _mm_mul_ps(_2, src[19])));
WinogradKernel2x2Block4x4SetInputStoreRow(tmp, dst + 20 * stride, stride);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetInput4t(const float* src, size_t srcS, size_t srcC, __m128 dst[25])
{
dst[0] = _mm_loadu_ps(src + 0 * srcS + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 0 * srcS + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 0 * srcS + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 0 * srcS + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 0 * srcS + 4 * srcC);
dst[5] = _mm_loadu_ps(src + 1 * srcS + 0 * srcC);
dst[6] = _mm_loadu_ps(src + 1 * srcS + 1 * srcC);
dst[7] = _mm_loadu_ps(src + 1 * srcS + 2 * srcC);
dst[8] = _mm_loadu_ps(src + 1 * srcS + 3 * srcC);
dst[9] = _mm_loadu_ps(src + 1 * srcS + 4 * srcC);
dst[10] = _mm_loadu_ps(src + 2 * srcS + 0 * srcC);
dst[11] = _mm_loadu_ps(src + 2 * srcS + 1 * srcC);
dst[12] = _mm_loadu_ps(src + 2 * srcS + 2 * srcC);
dst[13] = _mm_loadu_ps(src + 2 * srcS + 3 * srcC);
dst[14] = _mm_loadu_ps(src + 2 * srcS + 4 * srcC);
dst[15] = _mm_loadu_ps(src + 3 * srcS + 0 * srcC);
dst[16] = _mm_loadu_ps(src + 3 * srcS + 1 * srcC);
dst[17] = _mm_loadu_ps(src + 3 * srcS + 2 * srcC);
dst[18] = _mm_loadu_ps(src + 3 * srcS + 3 * srcC);
dst[19] = _mm_loadu_ps(src + 3 * srcS + 4 * srcC);
dst[20] = _mm_loadu_ps(src + 4 * srcS + 0 * srcC);
dst[21] = _mm_loadu_ps(src + 4 * srcS + 1 * srcC);
dst[22] = _mm_loadu_ps(src + 4 * srcS + 2 * srcC);
dst[23] = _mm_loadu_ps(src + 4 * srcS + 3 * srcC);
dst[24] = _mm_loadu_ps(src + 4 * srcS + 4 * srcC);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetInput4t(const float* src, size_t srcW, size_t srcC, float* dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[25];
WinogradKernel2x2Block4x4SetInput4t(src + c, srcS, srcC, tmp);
WinogradKernel2x2Block4x4SetInputStore(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[25];
WinogradKernel2x2Block4x4SetInput4t(src + srcC - F, srcS, srcC, tmp);
WinogradKernel2x2Block4x4SetInputStore(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetInput4t(const float* src, size_t srcS, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, __m128 dst[25])
{
for (size_t i = 0; i < 25; ++i)
dst[i] = _mm_setzero_ps();
for (size_t row = rowB; row < rowE; ++row)
for (size_t col = colB; col < colE; ++col)
dst[row * 5 + col] = _mm_loadu_ps(src + row * srcS + col * srcC);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetInput4t(const float* src, size_t srcW, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, float* dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[25];
WinogradKernel2x2Block4x4SetInput4t(src + c, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel2x2Block4x4SetInputStore(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[25];
WinogradKernel2x2Block4x4SetInput4t(src + srcC - F, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel2x2Block4x4SetInputStore(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel2x2Block4x4SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padY == padX && padW == padH && (padY + padH == 0 || padY + padH == 1));
if (trans ? (srcChannels < F) : true)
{
Base::WinogradKernel2x2Block4x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = srcHeight - 1 + padY + padH;
size_t dstW = srcWidth - 1 + padX + padW;
size_t dstH4 = AlignLo(dstH, 4);
size_t dstW4 = AlignLo(dstW, 4);
size_t noseW = Simd::Min<size_t>(5, dstW + 1);
size_t noseH = Simd::Min<size_t>(5, dstH + 1);
size_t startY = padY ? 4 : 0;
size_t startX = padX ? 4 : 0;
if (padY || padH)
{
if (dstH == dstH4)
dstH4 -= 4;
if (dstW == dstW4)
dstW4 -= 4;
if (padY)
src -= (srcWidth + 1) * (trans ? srcChannels : 1);
}
size_t tailW = dstW - dstW4 + (padW ? 0 : 1);
size_t tailH = dstH - dstH4 + (padH ? 0 : 1);
size_t row = 0, col = 0;
if (padY)
{
if (padX)
WinogradKernel2x2Block4x4SetInput4t(src, srcWidth, srcChannels, 1, noseH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel2x2Block4x4SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, 5, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block4x4SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, tailW, dst, dstStride), dst += srcChannels;
}
for (row = startY; row < dstH4; row += 4)
{
if (padX)
WinogradKernel2x2Block4x4SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, 5, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel2x2Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, 5, 0, tailW, dst, dstStride), dst += srcChannels;
}
if (row < dstH)
{
if (padX)
WinogradKernel2x2Block4x4SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, tailH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel2x2Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, 5, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel2x2Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, tailW, dst, dstStride), dst += srcChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutputGetRow(const __m128 * s, __m128 * d)
{
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _4 = _mm_set1_ps(4.0f);
const __m128 _8 = _mm_set1_ps(8.0f);
d[0] = _mm_add_ps(_mm_add_ps(s[0], s[1]), _mm_add_ps(s[2], s[3]));
d[1] = _mm_add_ps(_mm_sub_ps(s[1], s[2]), _mm_mul_ps(_2, s[3]));
d[2] = _mm_add_ps(_mm_add_ps(s[1], s[2]), _mm_mul_ps(_4, s[3]));
d[3] = _mm_add_ps(_mm_sub_ps(s[1], s[2]), _mm_add_ps(_mm_mul_ps(_8, s[3]), s[4]));
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutputLoad25(const float* src, size_t stride, __m128* dst)
{
__m128 s[25];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
s[9] = _mm_loadu_ps(src + 9 * stride);
s[10] = _mm_loadu_ps(src + 10 * stride);
s[11] = _mm_loadu_ps(src + 11 * stride);
s[12] = _mm_loadu_ps(src + 12 * stride);
s[13] = _mm_loadu_ps(src + 13 * stride);
s[14] = _mm_loadu_ps(src + 14 * stride);
s[15] = _mm_loadu_ps(src + 15 * stride);
s[16] = _mm_loadu_ps(src + 16 * stride);
s[17] = _mm_loadu_ps(src + 17 * stride);
s[18] = _mm_loadu_ps(src + 18 * stride);
s[19] = _mm_loadu_ps(src + 19 * stride);
s[20] = _mm_loadu_ps(src + 20 * stride);
s[21] = _mm_loadu_ps(src + 21 * stride);
s[22] = _mm_loadu_ps(src + 22 * stride);
s[23] = _mm_loadu_ps(src + 23 * stride);
s[24] = _mm_loadu_ps(src + 24 * stride);
const __m128 _2 = _mm_set1_ps(2.0f);
const __m128 _4 = _mm_set1_ps(4.0f);
const __m128 _8 = _mm_set1_ps(8.0f);
__m128 t[5];
t[0] = _mm_add_ps(_mm_add_ps(s[0], s[5]), _mm_add_ps(s[10], s[15]));
t[1] = _mm_add_ps(_mm_add_ps(s[1], s[6]), _mm_add_ps(s[11], s[16]));
t[2] = _mm_add_ps(_mm_add_ps(s[2], s[7]), _mm_add_ps(s[12], s[17]));
t[3] = _mm_add_ps(_mm_add_ps(s[3], s[8]), _mm_add_ps(s[13], s[18]));
t[4] = _mm_add_ps(_mm_add_ps(s[4], s[9]), _mm_add_ps(s[14], s[19]));
WinogradKernel2x2Block4x4SetOutputGetRow(t, dst + 0);
t[0] = _mm_add_ps(_mm_sub_ps(s[5], s[10]), _mm_mul_ps(_2, s[15]));
t[1] = _mm_add_ps(_mm_sub_ps(s[6], s[11]), _mm_mul_ps(_2, s[16]));
t[2] = _mm_add_ps(_mm_sub_ps(s[7], s[12]), _mm_mul_ps(_2, s[17]));
t[3] = _mm_add_ps(_mm_sub_ps(s[8], s[13]), _mm_mul_ps(_2, s[18]));
t[4] = _mm_add_ps(_mm_sub_ps(s[9], s[14]), _mm_mul_ps(_2, s[19]));
WinogradKernel2x2Block4x4SetOutputGetRow(t, dst + 4);
t[0] = _mm_add_ps(_mm_add_ps(s[5], s[10]), _mm_mul_ps(_4, s[15]));
t[1] = _mm_add_ps(_mm_add_ps(s[6], s[11]), _mm_mul_ps(_4, s[16]));
t[2] = _mm_add_ps(_mm_add_ps(s[7], s[12]), _mm_mul_ps(_4, s[17]));
t[3] = _mm_add_ps(_mm_add_ps(s[8], s[13]), _mm_mul_ps(_4, s[18]));
t[4] = _mm_add_ps(_mm_add_ps(s[9], s[14]), _mm_mul_ps(_4, s[19]));
WinogradKernel2x2Block4x4SetOutputGetRow(t, dst + 8);
t[0] = _mm_add_ps(_mm_sub_ps(s[5], s[10]), _mm_add_ps(_mm_mul_ps(_8, s[15]), s[20]));
t[1] = _mm_add_ps(_mm_sub_ps(s[6], s[11]), _mm_add_ps(_mm_mul_ps(_8, s[16]), s[21]));
t[2] = _mm_add_ps(_mm_sub_ps(s[7], s[12]), _mm_add_ps(_mm_mul_ps(_8, s[17]), s[22]));
t[3] = _mm_add_ps(_mm_sub_ps(s[8], s[13]), _mm_add_ps(_mm_mul_ps(_8, s[18]), s[23]));
t[4] = _mm_add_ps(_mm_sub_ps(s[9], s[14]), _mm_add_ps(_mm_mul_ps(_8, s[19]), s[24]));
WinogradKernel2x2Block4x4SetOutputGetRow(t, dst + 12);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutputStore16(const __m128 src[16], float* dst, size_t dstS, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstS + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 0 * dstS + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 0 * dstS + 2 * dstC, src[2]);
_mm_storeu_ps(dst + 0 * dstS + 3 * dstC, src[3]);
_mm_storeu_ps(dst + 1 * dstS + 0 * dstC, src[4]);
_mm_storeu_ps(dst + 1 * dstS + 1 * dstC, src[5]);
_mm_storeu_ps(dst + 1 * dstS + 2 * dstC, src[6]);
_mm_storeu_ps(dst + 1 * dstS + 3 * dstC, src[7]);
_mm_storeu_ps(dst + 2 * dstS + 0 * dstC, src[8]);
_mm_storeu_ps(dst + 2 * dstS + 1 * dstC, src[9]);
_mm_storeu_ps(dst + 2 * dstS + 2 * dstC, src[10]);
_mm_storeu_ps(dst + 2 * dstS + 3 * dstC, src[11]);
_mm_storeu_ps(dst + 3 * dstS + 0 * dstC, src[12]);
_mm_storeu_ps(dst + 3 * dstS + 1 * dstC, src[13]);
_mm_storeu_ps(dst + 3 * dstS + 2 * dstC, src[14]);
_mm_storeu_ps(dst + 3 * dstS + 3 * dstC, src[15]);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstW, size_t dstC)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[16];
WinogradKernel2x2Block4x4SetOutputLoad25(src + d, srcStride, tmp);
WinogradKernel2x2Block4x4SetOutputStore16(tmp, dst + d, dstS, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[16];
WinogradKernel2x2Block4x4SetOutputLoad25(src + dstC - F, srcStride, tmp);
WinogradKernel2x2Block4x4SetOutputStore16(tmp, dst + dstC - F, dstS, dstC);
}
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutputStore16(const __m128 src[16], float* dst, size_t dstS, size_t dstC, size_t rowE, size_t colE)
{
for (size_t row = 0; row < rowE; ++row)
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + row * dstS + col * dstC, src[row * 4 + col]);
}
SIMD_INLINE void WinogradKernel2x2Block4x4SetOutput4t(const float* src, size_t srcStride, float* dst, size_t dstW, size_t dstC, size_t rowE, size_t colE)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[16];
WinogradKernel2x2Block4x4SetOutputLoad25(src + d, srcStride, tmp);
WinogradKernel2x2Block4x4SetOutputStore16(tmp, dst + d, dstS, dstC, rowE, colE);
}
if (dstCF < dstC)
{
__m128 tmp[16];
WinogradKernel2x2Block4x4SetOutputLoad25(src + dstC - F, srcStride, tmp);
WinogradKernel2x2Block4x4SetOutputStore16(tmp, dst + dstC - F, dstS, dstC, rowE, colE);
}
}
void WinogradKernel2x2Block4x4SetOutput(const float* src, size_t srcStride, float* dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < F) : true)
{
Base::WinogradKernel2x2Block4x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileH = (dstHeight + 3) / 4;
size_t tileW = (dstWidth + 3) / 4;
size_t dstH4 = AlignLo(dstHeight, 4);
size_t dstW4 = AlignLo(dstWidth, 4);
size_t row, col;
for (row = 0; row < dstH4; row += 4)
{
for (col = 0; col < dstW4; col += 4)
WinogradKernel2x2Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel2x2Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, 4, dstWidth - col), src += dstChannels;
}
if (row < dstHeight)
{
for (col = 0; col < dstW4; col += 4)
WinogradKernel2x2Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, dstHeight - row, 4), src += dstChannels;
if (col < dstWidth)
WinogradKernel2x2Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col) * dstChannels, dstWidth, dstChannels, dstHeight - row, dstWidth - col), src += dstChannels;
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block2x2SetFilter(const __m128 src[9], float* dst, size_t stride)
{
const __m128 r2 = _mm_set1_ps(1.0f / 2.0f);
const __m128 r4 = _mm_set1_ps(1.0f / 4.0f);
_mm_storeu_ps(dst + 0 * stride, src[0]);
__m128 _0a2 = _mm_add_ps(src[0], src[2]);
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(_mm_add_ps(_0a2, src[1]), r2));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(_mm_sub_ps(_0a2, src[1]), r2));
_mm_storeu_ps(dst + 3 * stride, src[2]);
__m128 _0a6a3 = _mm_add_ps(_mm_add_ps(src[0], src[6]), src[3]);
_mm_storeu_ps(dst + 4 * stride, _mm_mul_ps(_0a6a3, r2));
__m128 _2a8a5 = _mm_add_ps(_mm_add_ps(src[2], src[8]), src[5]);
__m128 _1a7a4 = _mm_add_ps(_mm_add_ps(src[1], src[7]), src[4]);
_mm_storeu_ps(dst + 5 * stride, _mm_mul_ps(_mm_add_ps(_mm_add_ps(_0a6a3, _2a8a5), _1a7a4), r4));
_mm_storeu_ps(dst + 6 * stride, _mm_mul_ps(_mm_sub_ps(_mm_add_ps(_0a6a3, _2a8a5), _1a7a4), r4));
_mm_storeu_ps(dst + 7 * stride, _mm_mul_ps(_2a8a5, r2));
__m128 _0a6s3 = _mm_sub_ps(_mm_add_ps(src[0], src[6]), src[3]);
_mm_storeu_ps(dst + 8 * stride, _mm_mul_ps(_0a6s3, r2));
__m128 _2a8s5 = _mm_sub_ps(_mm_add_ps(src[2], src[8]), src[5]);
__m128 _1a7s4 = _mm_sub_ps(_mm_add_ps(src[1], src[7]), src[4]);
_mm_storeu_ps(dst + 9 * stride, _mm_mul_ps(_mm_add_ps(_mm_add_ps(_0a6s3, _2a8s5), _1a7s4), r4));
_mm_storeu_ps(dst + 10 * stride, _mm_mul_ps(_mm_sub_ps(_mm_add_ps(_0a6s3, _2a8s5), _1a7s4), r4));
_mm_storeu_ps(dst + 11 * stride, _mm_mul_ps(_2a8s5, r2));
_mm_storeu_ps(dst + 12 * stride, src[6]);
__m128 _6a8 = _mm_add_ps(src[6], src[8]);
_mm_storeu_ps(dst + 13 * stride, _mm_mul_ps(_mm_add_ps(_6a8, src[7]), r2));
_mm_storeu_ps(dst + 14 * stride, _mm_mul_ps(_mm_sub_ps(_6a8, src[7]), r2));
_mm_storeu_ps(dst + 15 * stride, src[8]);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetFilter4n(const float * src, float * dst, size_t stride)
{
__m128 _src[9];
Load4(src + 0, 9, _src + 0);
Load4(src + 4, 9, _src + 4);
_src[8] = _mm_setr_ps(src[8], src[17], src[26], src[35]);
WinogradKernel3x3Block2x2SetFilter(_src, dst, stride);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetFilter4t(const float * src, float * dst, size_t stride)
{
__m128 _src[9];
_src[0] = _mm_loadu_ps(src + 0 * stride);
_src[1] = _mm_loadu_ps(src + 1 * stride);
_src[2] = _mm_loadu_ps(src + 2 * stride);
_src[3] = _mm_loadu_ps(src + 3 * stride);
_src[4] = _mm_loadu_ps(src + 4 * stride);
_src[5] = _mm_loadu_ps(src + 5 * stride);
_src[6] = _mm_loadu_ps(src + 6 * stride);
_src[7] = _mm_loadu_ps(src + 7 * stride);
_src[8] = _mm_loadu_ps(src + 8 * stride);
WinogradKernel3x3Block2x2SetFilter(_src, dst, stride);
}
void WinogradKernel3x3Block2x2SetFilter(const float * src, size_t size, float * dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel3x3Block2x2SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel3x3Block2x2SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 36, dst += 4)
WinogradKernel3x3Block2x2SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 9, dst += 1)
Base::WinogradKernel3x3Block2x2SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block2x2SetInputLoad4n(const float * src, __m128 * dst)
{
__m128 a0 = _mm_loadu_ps(src + 0);
__m128 a1 = _mm_loadu_ps(src + 2);
__m128 a2 = _mm_loadu_ps(src + 4);
__m128 a3 = _mm_loadu_ps(src + 6);
dst[0] = _mm_shuffle_ps(a0, a2, 0x88);
dst[1] = _mm_shuffle_ps(a0, a2, 0xDD);
dst[2] = _mm_shuffle_ps(a1, a3, 0x88);
dst[3] = _mm_shuffle_ps(a1, a3, 0xDD);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInputLoad4n(const float * src, __m128 * dst, PadType pad)
{
__m128 a0 = (pad == PadNose1 ? LoadPadZeroNose1(src + 0) : _mm_loadu_ps(src + 0));
__m128 a1 = _mm_loadu_ps(src + 2);
__m128 a2 = _mm_loadu_ps(src + 4);
__m128 a3 = (pad == PadTail2 ? LoadPadZeroTail2(src + 6) : (pad == PadTail1 ? LoadPadZeroTail1(src + 6) : _mm_loadu_ps(src + 6)));
dst[0] = _mm_shuffle_ps(a0, a2, 0x88);
dst[1] = _mm_shuffle_ps(a0, a2, 0xDD);
dst[2] = _mm_shuffle_ps(a1, a3, 0x88);
dst[3] = _mm_shuffle_ps(a1, a3, 0xDD);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInputLoad4z(__m128 * dst)
{
dst[0] = _mm_setzero_ps();
dst[1] = _mm_setzero_ps();
dst[2] = _mm_setzero_ps();
dst[3] = _mm_setzero_ps();
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4Store(const __m128 * src, float * dst, size_t stride)
{
_mm_storeu_ps(dst + 0 * stride, _mm_sub_ps(_mm_sub_ps(src[0], src[8]), _mm_sub_ps(src[2], src[10])));
_mm_storeu_ps(dst + 1 * stride, _mm_add_ps(_mm_sub_ps(src[1], src[9]), _mm_sub_ps(src[2], src[10])));
_mm_storeu_ps(dst + 2 * stride, _mm_sub_ps(_mm_sub_ps(src[2], src[10]), _mm_sub_ps(src[1], src[9])));
_mm_storeu_ps(dst + 3 * stride, _mm_sub_ps(_mm_sub_ps(src[1], src[9]), _mm_sub_ps(src[3], src[11])));
_mm_storeu_ps(dst + 4 * stride, _mm_sub_ps(_mm_add_ps(src[4], src[8]), _mm_add_ps(src[6], src[10])));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(_mm_add_ps(src[5], src[9]), _mm_add_ps(src[6], src[10])));
_mm_storeu_ps(dst + 6 * stride, _mm_sub_ps(_mm_add_ps(src[6], src[10]), _mm_add_ps(src[5], src[9])));
_mm_storeu_ps(dst + 7 * stride, _mm_sub_ps(_mm_add_ps(src[5], src[9]), _mm_add_ps(src[7], src[11])));
_mm_storeu_ps(dst + 8 * stride, _mm_sub_ps(_mm_sub_ps(src[8], src[4]), _mm_sub_ps(src[10], src[6])));
_mm_storeu_ps(dst + 9 * stride, _mm_add_ps(_mm_sub_ps(src[9], src[5]), _mm_sub_ps(src[10], src[6])));
_mm_storeu_ps(dst + 10 * stride, _mm_sub_ps(_mm_sub_ps(src[10], src[6]), _mm_sub_ps(src[9], src[5])));
_mm_storeu_ps(dst + 11 * stride, _mm_sub_ps(_mm_sub_ps(src[9], src[5]), _mm_sub_ps(src[11], src[7])));
_mm_storeu_ps(dst + 12 * stride, _mm_sub_ps(_mm_sub_ps(src[4], src[12]), _mm_sub_ps(src[6], src[14])));
_mm_storeu_ps(dst + 13 * stride, _mm_add_ps(_mm_sub_ps(src[5], src[13]), _mm_sub_ps(src[6], src[14])));
_mm_storeu_ps(dst + 14 * stride, _mm_sub_ps(_mm_sub_ps(src[6], src[14]), _mm_sub_ps(src[5], src[13])));
_mm_storeu_ps(dst + 15 * stride, _mm_sub_ps(_mm_sub_ps(src[5], src[13]), _mm_sub_ps(src[7], src[15])));
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4n(const float * src, size_t srcStride, float * dst, size_t dstStride)
{
__m128 t[16];
WinogradKernel3x3Block2x2SetInputLoad4n(src + 0 * srcStride, t + 0);
WinogradKernel3x3Block2x2SetInputLoad4n(src + 1 * srcStride, t + 4);
WinogradKernel3x3Block2x2SetInputLoad4n(src + 2 * srcStride, t + 8);
WinogradKernel3x3Block2x2SetInputLoad4n(src + 3 * srcStride, t + 12);
WinogradKernel3x3Block2x2SetInput4Store(t, dst, dstStride);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4n(const float * src, size_t srcStride, PadType rowPad, PadType colPad, float * dst, size_t dstStride)
{
__m128 t[16];
if (rowPad == PadNose1)
WinogradKernel3x3Block2x2SetInputLoad4z(t + 0);
else
WinogradKernel3x3Block2x2SetInputLoad4n(src + 0 * srcStride, t + 0, colPad);
WinogradKernel3x3Block2x2SetInputLoad4n(src + 1 * srcStride, t + 4, colPad);
if (rowPad == PadTail2)
WinogradKernel3x3Block2x2SetInputLoad4z(t + 8);
else
WinogradKernel3x3Block2x2SetInputLoad4n(src + 2 * srcStride, t + 8, colPad);
if (rowPad >= PadTail1)
WinogradKernel3x3Block2x2SetInputLoad4z(t + 12);
else
WinogradKernel3x3Block2x2SetInputLoad4n(src + 3 * srcStride, t + 12, colPad);
WinogradKernel3x3Block2x2SetInput4Store(t, dst, dstStride);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4t(const float * src, size_t srcS, size_t srcC, __m128 dst[16])
{
dst[0] = _mm_loadu_ps(src + 0 * srcS + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 0 * srcS + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 0 * srcS + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 0 * srcS + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 1 * srcS + 0 * srcC);
dst[5] = _mm_loadu_ps(src + 1 * srcS + 1 * srcC);
dst[6] = _mm_loadu_ps(src + 1 * srcS + 2 * srcC);
dst[7] = _mm_loadu_ps(src + 1 * srcS + 3 * srcC);
dst[8] = _mm_loadu_ps(src + 2 * srcS + 0 * srcC);
dst[9] = _mm_loadu_ps(src + 2 * srcS + 1 * srcC);
dst[10] = _mm_loadu_ps(src + 2 * srcS + 2 * srcC);
dst[11] = _mm_loadu_ps(src + 2 * srcS + 3 * srcC);
dst[12] = _mm_loadu_ps(src + 3 * srcS + 0 * srcC);
dst[13] = _mm_loadu_ps(src + 3 * srcS + 1 * srcC);
dst[14] = _mm_loadu_ps(src + 3 * srcS + 2 * srcC);
dst[15] = _mm_loadu_ps(src + 3 * srcS + 3 * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4t(const float * src, size_t srcW, size_t srcC, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[16];
WinogradKernel3x3Block2x2SetInput4t(src + c, srcS, srcC, tmp);
WinogradKernel3x3Block2x2SetInput4Store(tmp, dst + c, dstStride);
}
if(srcCF < srcC)
{
__m128 tmp[16];
WinogradKernel3x3Block2x2SetInput4t(src + srcC - F, srcS, srcC, tmp);
WinogradKernel3x3Block2x2SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4t(const float * src, size_t srcS, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, __m128 dst[16])
{
for (size_t i = 0; i < 16; ++i)
dst[i] = _mm_setzero_ps();
for (size_t row = rowB; row < rowE; ++row)
for (size_t col = colB; col < colE; ++col)
dst[row * 4 + col] = _mm_loadu_ps(src + row * srcS + col * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetInput4t(const float * src, size_t srcW, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[16];
WinogradKernel3x3Block2x2SetInput4t(src + c, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block2x2SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[16];
WinogradKernel3x3Block2x2SetInput4t(src + srcC - F, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block2x2SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel3x3Block2x2SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padY == padX && padY == padH && padY == padW && (padY == 0 || padY == 1));
SimdBool pad = padY > 0 ? SimdTrue : SimdFalse;
if (trans ? (srcChannels < 4) : (srcHeight < 4 || srcWidth < 10))
{
Base::WinogradKernel3x3Block2x2SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = pad ? srcHeight : srcHeight - 2;
size_t dstW = pad ? srcWidth : srcWidth - 2;
size_t tileH = (dstH + 1) / 2;
size_t tileW = (dstW + 1) / 2;
size_t dstH2 = AlignLo(dstH, 2);
size_t dstW2 = AlignLo(dstW, 2);
if (trans)
{
size_t noseW = Simd::Min<size_t>(4, dstW + 1);
size_t noseH = Simd::Min<size_t>(4, dstH + 1);
size_t start = pad ? 2 : 0;
if (pad)
{
if (dstH == dstH2)
dstH2 -= 2;
if (dstW == dstW2)
dstW2 -= 2;
src -= (srcWidth + 1)*srcChannels;
}
size_t tailW = dstW - dstW2 + (pad ? 1 : 2);
size_t tailH = dstH - dstH2 + (pad ? 1 : 2);
size_t row = 0, col = 0;
if (pad)
{
if (pad)
WinogradKernel3x3Block2x2SetInput4t(src, srcWidth, srcChannels, 1, noseH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW2; col += 2)
WinogradKernel3x3Block2x2SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, 4, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block2x2SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, tailW, dst, dstStride), dst += srcChannels;
}
for (row = start; row < dstH2; row += 2)
{
if (pad)
WinogradKernel3x3Block2x2SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, 4, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW2; col += 2)
WinogradKernel3x3Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, 4, 0, tailW, dst, dstStride), dst += srcChannels;
}
if (row < dstH)
{
if (pad)
WinogradKernel3x3Block2x2SetInput4t(src + row * srcWidth* srcChannels, srcWidth, srcChannels, 0, tailH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW2; col += 2)
WinogradKernel3x3Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, 4, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block2x2SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, tailW, dst, dstStride), dst += srcChannels;
}
}
else
{
size_t dstW8 = AlignLo(dstW, 8);
if (pad && dstW8 == dstW)
dstW8 -= 8;
PadType rowPad = dstH2 < dstH ? PadTail1 : PadNone;
PadType colPad = dstW2 < dstW ? PadTail1 : PadNone;
size_t tailCol = dstW2 < dstW ? dstW - 7 : dstW - 8;
size_t tailRow = dstH2 < dstH ? dstH - 1 : dstH - 2;
bool specialColTail = dstW8 < dstW || pad;
bool specialRowTail = dstH2 < dstH || pad;
if (pad)
{
src -= srcWidth + 1;
rowPad = dstH2 < dstH ? PadTail2 : PadTail1;
colPad = dstW2 < dstW ? PadTail2 : PadTail1;
if (dstH2 == dstH)
dstH2 -= 2;
}
for (size_t c = 0; c < srcChannels; ++c)
{
size_t row = 0, tileY = 0;
if (pad)
{
size_t col = 0, tileX = 0;
const float * s = src + row * srcWidth;
float * d = dst + tileY * tileW;
if (pad)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, PadNose1, PadNose1, d + tileX, dstStride), col += 8, tileX += 4;
for (; col < dstW8; col += 8, tileX += 4)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, PadNose1, PadNone, d + tileX, dstStride);
if (specialColTail)
WinogradKernel3x3Block2x2SetInput4n(s + tailCol, srcWidth, PadNose1, colPad, d + tileW - 4, dstStride);
row += 2, tileY += 1;
}
for (; row < dstH2; row += 2, tileY += 1)
{
size_t col = 0, tileX = 0;
const float * s = src + row * srcWidth;
float * d = dst + tileY * tileW;
if (pad)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, PadNone, PadNose1, d + tileX, dstStride), col += 8, tileX += 4;
for (; col < dstW8; col += 8, tileX += 4)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, d + tileX, dstStride);
if (specialColTail)
WinogradKernel3x3Block2x2SetInput4n(s + tailCol, srcWidth, PadNone, colPad, d + tileW - 4, dstStride);
}
if (specialRowTail)
{
size_t col = 0, tileX = 0;
const float * s = src + tailRow * srcWidth;
float * d = dst + (tileH - 1) * tileW;
if (pad)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, rowPad, PadNose1, d + tileX, dstStride), col += 8, tileX += 4;
for (; col < dstW8; col += 8, tileX += 4)
WinogradKernel3x3Block2x2SetInput4n(s + col, srcWidth, rowPad, PadNone, d + tileX, dstStride);
if (specialColTail)
WinogradKernel3x3Block2x2SetInput4n(s + tailCol, srcWidth, rowPad, colPad, d + tileW - 4, dstStride);
}
src += srcWidth * srcHeight;
dst += tileW * tileH;
}
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutputLoad4(const float * src, size_t stride, __m128 * dst)
{
__m128 s0 = _mm_loadu_ps(src + 0 * stride);
__m128 s1 = _mm_loadu_ps(src + 1 * stride);
__m128 s2 = _mm_loadu_ps(src + 2 * stride);
__m128 s3 = _mm_loadu_ps(src + 3 * stride);
dst[0] = _mm_add_ps(_mm_add_ps(s0, s1), s2);
dst[1] = _mm_sub_ps(_mm_sub_ps(s1, s2), s3);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutputLoad16(const float * src, size_t stride, __m128 * dst)
{
__m128 tmp[8];
WinogradKernel3x3Block2x2SetOutputLoad4(src + 0 * stride, stride, tmp + 0);
WinogradKernel3x3Block2x2SetOutputLoad4(src + 4 * stride, stride, tmp + 2);
WinogradKernel3x3Block2x2SetOutputLoad4(src + 8 * stride, stride, tmp + 4);
WinogradKernel3x3Block2x2SetOutputLoad4(src + 12 * stride, stride, tmp + 6);
dst[0] = _mm_add_ps(_mm_add_ps(tmp[0], tmp[2]), tmp[4]);
dst[1] = _mm_add_ps(_mm_add_ps(tmp[1], tmp[3]), tmp[5]);
dst[2] = _mm_sub_ps(_mm_sub_ps(tmp[2], tmp[4]), tmp[6]);
dst[3] = _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[5]), tmp[7]);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutput4n(const float * src, size_t srcStride, float * dst, size_t dstStride)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src, srcStride, tmp);
_mm_storeu_ps(dst + 0 * dstStride + 0, _mm_unpacklo_ps(tmp[0], tmp[1]));
_mm_storeu_ps(dst + 0 * dstStride + 4, _mm_unpackhi_ps(tmp[0], tmp[1]));
_mm_storeu_ps(dst + 1 * dstStride + 0, _mm_unpacklo_ps(tmp[2], tmp[3]));
_mm_storeu_ps(dst + 1 * dstStride + 4, _mm_unpackhi_ps(tmp[2], tmp[3]));
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutput4n(const float * src, size_t srcStride, float * dst, size_t dstStride, bool lastRow, bool lastCol, const __m128 & mask)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src, srcStride, tmp);
_mm_storeu_ps(dst + 0, _mm_unpacklo_ps(tmp[0], tmp[1]));
if(lastCol)
_mm_storeu_ps(dst + 4, _mm_unpackhi_ps(tmp[0], tmp[1]));
else
StoreMasked<false>(dst + 4, _mm_unpackhi_ps(tmp[0], tmp[1]), mask);
if (lastRow)
{
dst += dstStride;
_mm_storeu_ps(dst + 0, _mm_unpacklo_ps(tmp[2], tmp[3]));
if (lastCol)
_mm_storeu_ps(dst + 4, _mm_unpackhi_ps(tmp[2], tmp[3]));
else
StoreMasked<false>(dst + 4, _mm_unpackhi_ps(tmp[2], tmp[3]), mask);
}
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutputStore4(const __m128 src[4], float * dst, size_t dstS, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstS + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 0 * dstS + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 1 * dstS + 0 * dstC, src[2]);
_mm_storeu_ps(dst + 1 * dstS + 1 * dstC, src[3]);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src + d, srcStride, tmp);
WinogradKernel3x3Block2x2SetOutputStore4(tmp, dst + d, dstS, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block2x2SetOutputStore4(tmp, dst + dstC - F, dstS, dstC);
}
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutputStore4(const __m128 src[4], float * dst, size_t dstS, size_t dstC, size_t rowE, size_t colE)
{
for (size_t row = 0; row < rowE; ++row)
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + row * dstS + col * dstC, src[row * 2 + col]);
}
SIMD_INLINE void WinogradKernel3x3Block2x2SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC, size_t rowE, size_t colE)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src + d, srcStride, tmp);
WinogradKernel3x3Block2x2SetOutputStore4(tmp, dst + d, dstS, dstC, rowE, colE);
}
if (dstCF < dstC)
{
__m128 tmp[4];
WinogradKernel3x3Block2x2SetOutputLoad16(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block2x2SetOutputStore4(tmp, dst + dstC - F, dstS, dstC, rowE, colE);
}
}
void WinogradKernel3x3Block2x2SetOutput(const float * src, size_t srcStride, float * dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < 4) : (dstHeight < 2 || dstWidth < 8))
{
Base::WinogradKernel3x3Block2x2SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileH = (dstHeight + 1) / 2;
size_t tileW = (dstWidth + 1) / 2;
size_t dstH2 = AlignLo(dstHeight, 2);
size_t dstW2 = AlignLo(dstWidth, 2);
if (trans)
{
size_t row, col;
for (row = 0; row < dstH2; row += 2)
{
for (col = 0; col < dstW2; col += 2)
WinogradKernel3x3Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, 2, dstWidth - col), src += dstChannels;
}
if (row < dstHeight)
{
for (col = 0; col < dstW2; col += 2)
WinogradKernel3x3Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, 2), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block2x2SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, dstWidth - col), src += dstChannels;
}
}
else
{
size_t dstW8 = AlignLo(dstWidth, 8);
__m128 tailMask = LeftNotZero32f(4 + dstW2 - dstWidth);
size_t tailCol = dstW2 < dstWidth ? dstWidth - 7 : dstWidth - 8;
size_t tailRow = dstH2 < dstHeight ? dstHeight - 1 : dstHeight - 2;
for (size_t c = 0; c < dstChannels; ++c)
{
size_t row = 0, tileY = 0;
for (; row < dstH2; row += 2, tileY += 1)
{
size_t col = 0, tileX = 0;
const float * s = src + tileY * tileW;
float * d = dst + row * dstWidth;
for (; col < dstW8; col += 8, tileX += 4)
WinogradKernel3x3Block2x2SetOutput4n(s + tileX, srcStride, d + col, dstWidth);
if (col < dstWidth)
WinogradKernel3x3Block2x2SetOutput4n(s + tileW - 4, srcStride, d + tailCol, dstWidth, true, false, tailMask);
}
if (row < dstHeight)
{
size_t col = 0, tileX = 0;
const float * s = src + (tileH - 1) * tileW;
float * d = dst + (dstHeight - 1) * dstWidth;
for (; col < dstW8; col += 8, tileX += 4)
WinogradKernel3x3Block2x2SetOutput4n(s + tileX, srcStride, d + col, dstWidth, false, true, tailMask);
if (col < dstWidth)
WinogradKernel3x3Block2x2SetOutput4n(s + tileW - 4, srcStride, d + tailCol, dstWidth, false, false, tailMask);
}
src += tileW * tileH;
dst += dstHeight * dstWidth;
}
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block3x3SetFilter4Row(const __m128 * t, float * dst, size_t stride)
{
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 r3 = _mm_set1_ps(1.0f / 3.0f);
const __m128 r2 = _mm_set1_ps(1.0f / 2.0f);
const __m128 f2_3 = _mm_set1_ps(2.0f / 3.0f);
const __m128 mr2 = _mm_set1_ps(-1.0f / 2.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_mul_ps(r2, t[0]));
__m128 t0 = _mm_add_ps(t[0], t[2]);
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(mr2, _mm_add_ps(t0, t[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(r6, _mm_sub_ps(t[1], t0)));
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(_mm_mul_ps(r6, t[0]), _mm_add_ps(_mm_mul_ps(r3, t[1]), _mm_mul_ps(f2_3, t[2]))));
_mm_storeu_ps(dst + 4 * stride, t[2]);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetFilter4All(const __m128 * s, float * dst, size_t stride)
{
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 r3 = _mm_set1_ps(1.0f / 3.0f);
const __m128 r2 = _mm_set1_ps(1.0f / 2.0f);
const __m128 f2_3 = _mm_set1_ps(2.0f / 3.0f);
const __m128 mr2 = _mm_set1_ps(-1.0f / 2.0f);
__m128 t[3];
t[0] = _mm_mul_ps(r2, s[0]);
t[1] = _mm_mul_ps(r2, s[1]);
t[2] = _mm_mul_ps(r2, s[2]);
WinogradKernel3x3Block3x3SetFilter4Row(t, dst + 0 * stride, stride);
t[0] = _mm_mul_ps(mr2, _mm_add_ps(_mm_add_ps(s[0], s[6]), s[3]));
t[1] = _mm_mul_ps(mr2, _mm_add_ps(_mm_add_ps(s[1], s[7]), s[4]));
t[2] = _mm_mul_ps(mr2, _mm_add_ps(_mm_add_ps(s[2], s[8]), s[5]));
WinogradKernel3x3Block3x3SetFilter4Row(t, dst + 5 * stride, stride);
t[0] = _mm_mul_ps(r6, _mm_sub_ps(s[3], _mm_add_ps(s[0], s[6])));
t[1] = _mm_mul_ps(r6, _mm_sub_ps(s[4], _mm_add_ps(s[1], s[7])));
t[2] = _mm_mul_ps(r6, _mm_sub_ps(s[5], _mm_add_ps(s[2], s[8])));
WinogradKernel3x3Block3x3SetFilter4Row(t, dst + 10 * stride, stride);
t[0] = _mm_add_ps(_mm_mul_ps(r6, s[0]), _mm_add_ps(_mm_mul_ps(r3, s[3]), _mm_mul_ps(f2_3, s[6])));
t[1] = _mm_add_ps(_mm_mul_ps(r6, s[1]), _mm_add_ps(_mm_mul_ps(r3, s[4]), _mm_mul_ps(f2_3, s[7])));
t[2] = _mm_add_ps(_mm_mul_ps(r6, s[2]), _mm_add_ps(_mm_mul_ps(r3, s[5]), _mm_mul_ps(f2_3, s[8])));
WinogradKernel3x3Block3x3SetFilter4Row(t, dst + 15 * stride, stride);
WinogradKernel3x3Block3x3SetFilter4Row(s + 6, dst + 20 * stride, stride);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetFilter4n(const float * src, float * dst, size_t stride)
{
__m128 s[9];
Load4(src + 0, 9, s + 0);
Load4(src + 4, 9, s + 4);
s[8] = _mm_setr_ps(src[8], src[17], src[26], src[35]);
WinogradKernel3x3Block3x3SetFilter4All(s, dst + 0 * stride, stride);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetFilter4t(const float * src, float * dst, size_t stride)
{
__m128 s[9];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
WinogradKernel3x3Block3x3SetFilter4All(s, dst + 0 * stride, stride);
}
void WinogradKernel3x3Block3x3SetFilter(const float * src, size_t size, float * dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel3x3Block3x3SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel3x3Block3x3SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 36, dst += 4)
WinogradKernel3x3Block3x3SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 9, dst += 1)
Base::WinogradKernel3x3Block3x3SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block3x3SetInput4Store(const __m128 src[25], float * dst, size_t stride)
{
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _3 = _mm_set1_ps(3.0f);
__m128 tmp[5];
tmp[0] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[0], src[10])), _mm_sub_ps(src[15], src[5]));
tmp[1] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[1], src[11])), _mm_sub_ps(src[16], src[6]));
tmp[2] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[2], src[12])), _mm_sub_ps(src[17], src[7]));
tmp[3] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[3], src[13])), _mm_sub_ps(src[18], src[8]));
tmp[4] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[4], src[14])), _mm_sub_ps(src[19], src[9]));
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[0], tmp[2])), _mm_sub_ps(tmp[3], tmp[1])));
_mm_storeu_ps(dst + 1 * stride, _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[2]), _mm_mul_ps(_2, tmp[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_add_ps(_mm_mul_ps(_2, tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_3, tmp[2]))));
_mm_storeu_ps(dst + 3 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 4 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
tmp[0] = _mm_sub_ps(_mm_sub_ps(src[15], src[10]), _mm_mul_ps(_2, src[5]));
tmp[1] = _mm_sub_ps(_mm_sub_ps(src[16], src[11]), _mm_mul_ps(_2, src[6]));
tmp[2] = _mm_sub_ps(_mm_sub_ps(src[17], src[12]), _mm_mul_ps(_2, src[7]));
tmp[3] = _mm_sub_ps(_mm_sub_ps(src[18], src[13]), _mm_mul_ps(_2, src[8]));
tmp[4] = _mm_sub_ps(_mm_sub_ps(src[19], src[14]), _mm_mul_ps(_2, src[9]));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[0], tmp[2])), _mm_sub_ps(tmp[3], tmp[1])));
_mm_storeu_ps(dst + 6 * stride, _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[2]), _mm_mul_ps(_2, tmp[1])));
_mm_storeu_ps(dst + 7 * stride, _mm_add_ps(_mm_mul_ps(_2, tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_3, tmp[2]))));
_mm_storeu_ps(dst + 8 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 9 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
tmp[0] = _mm_add_ps(_mm_mul_ps(_2, src[5]), _mm_sub_ps(src[15], _mm_mul_ps(_3, src[10])));
tmp[1] = _mm_add_ps(_mm_mul_ps(_2, src[6]), _mm_sub_ps(src[16], _mm_mul_ps(_3, src[11])));
tmp[2] = _mm_add_ps(_mm_mul_ps(_2, src[7]), _mm_sub_ps(src[17], _mm_mul_ps(_3, src[12])));
tmp[3] = _mm_add_ps(_mm_mul_ps(_2, src[8]), _mm_sub_ps(src[18], _mm_mul_ps(_3, src[13])));
tmp[4] = _mm_add_ps(_mm_mul_ps(_2, src[9]), _mm_sub_ps(src[19], _mm_mul_ps(_3, src[14])));
_mm_storeu_ps(dst + 10 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[0], tmp[2])), _mm_sub_ps(tmp[3], tmp[1])));
_mm_storeu_ps(dst + 11 * stride, _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[2]), _mm_mul_ps(_2, tmp[1])));
_mm_storeu_ps(dst + 12 * stride, _mm_add_ps(_mm_mul_ps(_2, tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_3, tmp[2]))));
_mm_storeu_ps(dst + 13 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 14 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
tmp[0] = _mm_sub_ps(src[15], src[5]);
tmp[1] = _mm_sub_ps(src[16], src[6]);
tmp[2] = _mm_sub_ps(src[17], src[7]);
tmp[3] = _mm_sub_ps(src[18], src[8]);
tmp[4] = _mm_sub_ps(src[19], src[9]);
_mm_storeu_ps(dst + 15 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[0], tmp[2])), _mm_sub_ps(tmp[3], tmp[1])));
_mm_storeu_ps(dst + 16 * stride, _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[2]), _mm_mul_ps(_2, tmp[1])));
_mm_storeu_ps(dst + 17 * stride, _mm_add_ps(_mm_mul_ps(_2, tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_3, tmp[2]))));
_mm_storeu_ps(dst + 18 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 19 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
tmp[0] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[5], src[15])), _mm_sub_ps(src[20], src[10]));
tmp[1] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[6], src[16])), _mm_sub_ps(src[21], src[11]));
tmp[2] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[7], src[17])), _mm_sub_ps(src[22], src[12]));
tmp[3] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[8], src[18])), _mm_sub_ps(src[23], src[13]));
tmp[4] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[9], src[19])), _mm_sub_ps(src[24], src[14]));
_mm_storeu_ps(dst + 20 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[0], tmp[2])), _mm_sub_ps(tmp[3], tmp[1])));
_mm_storeu_ps(dst + 21 * stride, _mm_sub_ps(_mm_sub_ps(tmp[3], tmp[2]), _mm_mul_ps(_2, tmp[1])));
_mm_storeu_ps(dst + 22 * stride, _mm_add_ps(_mm_mul_ps(_2, tmp[1]), _mm_sub_ps(tmp[3], _mm_mul_ps(_3, tmp[2]))));
_mm_storeu_ps(dst + 23 * stride, _mm_sub_ps(tmp[3], tmp[1]));
_mm_storeu_ps(dst + 24 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetInput4t(const float * src, size_t srcS, size_t srcC, __m128 dst[25])
{
dst[0] = _mm_loadu_ps(src + 0 * srcS + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 0 * srcS + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 0 * srcS + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 0 * srcS + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 0 * srcS + 4 * srcC);
dst[5] = _mm_loadu_ps(src + 1 * srcS + 0 * srcC);
dst[6] = _mm_loadu_ps(src + 1 * srcS + 1 * srcC);
dst[7] = _mm_loadu_ps(src + 1 * srcS + 2 * srcC);
dst[8] = _mm_loadu_ps(src + 1 * srcS + 3 * srcC);
dst[9] = _mm_loadu_ps(src + 1 * srcS + 4 * srcC);
dst[10] = _mm_loadu_ps(src + 2 * srcS + 0 * srcC);
dst[11] = _mm_loadu_ps(src + 2 * srcS + 1 * srcC);
dst[12] = _mm_loadu_ps(src + 2 * srcS + 2 * srcC);
dst[13] = _mm_loadu_ps(src + 2 * srcS + 3 * srcC);
dst[14] = _mm_loadu_ps(src + 2 * srcS + 4 * srcC);
dst[15] = _mm_loadu_ps(src + 3 * srcS + 0 * srcC);
dst[16] = _mm_loadu_ps(src + 3 * srcS + 1 * srcC);
dst[17] = _mm_loadu_ps(src + 3 * srcS + 2 * srcC);
dst[18] = _mm_loadu_ps(src + 3 * srcS + 3 * srcC);
dst[19] = _mm_loadu_ps(src + 3 * srcS + 4 * srcC);
dst[20] = _mm_loadu_ps(src + 4 * srcS + 0 * srcC);
dst[21] = _mm_loadu_ps(src + 4 * srcS + 1 * srcC);
dst[22] = _mm_loadu_ps(src + 4 * srcS + 2 * srcC);
dst[23] = _mm_loadu_ps(src + 4 * srcS + 3 * srcC);
dst[24] = _mm_loadu_ps(src + 4 * srcS + 4 * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetInput4t(const float * src, size_t srcW, size_t srcC, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[25];
WinogradKernel3x3Block3x3SetInput4t(src + c, srcS, srcC, tmp);
WinogradKernel3x3Block3x3SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[25];
WinogradKernel3x3Block3x3SetInput4t(src + srcC - F, srcS, srcC, tmp);
WinogradKernel3x3Block3x3SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetInput4t(const float * src, size_t srcS, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, __m128 dst[25])
{
for (size_t i = 0; i < 25; ++i)
dst[i] = _mm_setzero_ps();
for (size_t row = rowB; row < rowE; ++row)
for (size_t col = colB; col < colE; ++col)
dst[row * 5 + col] = _mm_loadu_ps(src + row * srcS + col * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetInput4t(const float * src, size_t srcW, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[25];
WinogradKernel3x3Block3x3SetInput4t(src + c, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block3x3SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[25];
WinogradKernel3x3Block3x3SetInput4t(src + srcC - F, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block3x3SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel3x3Block3x3SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
assert(padY == padX && padY == padH && padY == padW && (padY == 0 || padY == 1));
SimdBool pad = padY > 0 ? SimdTrue : SimdFalse;
if (trans ? (srcChannels < 4) : (srcHeight < 5 || srcWidth < 11))
{
Base::WinogradKernel3x3Block3x3SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
size_t dstH = pad ? srcHeight : srcHeight - 2;
size_t dstW = pad ? srcWidth : srcWidth - 2;
size_t tileH = (dstH + 2) / 3;
size_t tileW = (dstW + 2) / 3;
size_t dstH3 = AlignLoAny(dstH, 3);
size_t dstW3 = AlignLoAny(dstW, 3);
if (trans)
{
size_t noseW = Simd::Min<size_t>(5, dstW + 1);
size_t noseH = Simd::Min<size_t>(5, dstH + 1);
size_t start = pad ? 3 : 0;
if (pad)
{
if (dstH == dstH3)
dstH3 -= 3;
if (dstW == dstW3)
dstW3 -= 3;
src -= (srcWidth + 1)*srcChannels;
}
size_t tailW = dstW - dstW3 + (pad ? 1 : 2);
size_t tailH = dstH - dstH3 + (pad ? 1 : 2);
size_t row = 0, col = 0;
if (pad)
{
if (pad)
WinogradKernel3x3Block3x3SetInput4t(src, srcWidth, srcChannels, 1, noseH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW3; col += 3)
WinogradKernel3x3Block3x3SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, 5, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block3x3SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, tailW, dst, dstStride), dst += srcChannels;
}
for (row = start; row < dstH3; row += 3)
{
if (pad)
WinogradKernel3x3Block3x3SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, 5, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW3; col += 3)
WinogradKernel3x3Block3x3SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block3x3SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, 5, 0, tailW, dst, dstStride), dst += srcChannels;
}
if (row < dstH)
{
if (pad)
WinogradKernel3x3Block3x3SetInput4t(src + row * srcWidth* srcChannels, srcWidth, srcChannels, 0, tailH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = start; col < dstW3; col += 3)
WinogradKernel3x3Block3x3SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, 5, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block3x3SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, tailW, dst, dstStride), dst += srcChannels;
}
}
else
{
Base::WinogradKernel3x3Block3x3SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block3x3SetOutputLoad25(const float * src, size_t stride, __m128 dst[9])
{
__m128 s[25];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
s[9] = _mm_loadu_ps(src + 9 * stride);
s[10] = _mm_loadu_ps(src + 10 * stride);
s[11] = _mm_loadu_ps(src + 11 * stride);
s[12] = _mm_loadu_ps(src + 12 * stride);
s[13] = _mm_loadu_ps(src + 13 * stride);
s[14] = _mm_loadu_ps(src + 14 * stride);
s[15] = _mm_loadu_ps(src + 15 * stride);
s[16] = _mm_loadu_ps(src + 16 * stride);
s[17] = _mm_loadu_ps(src + 17 * stride);
s[18] = _mm_loadu_ps(src + 18 * stride);
s[19] = _mm_loadu_ps(src + 19 * stride);
s[20] = _mm_loadu_ps(src + 20 * stride);
s[21] = _mm_loadu_ps(src + 21 * stride);
s[22] = _mm_loadu_ps(src + 22 * stride);
s[23] = _mm_loadu_ps(src + 23 * stride);
s[24] = _mm_loadu_ps(src + 24 * stride);
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 t[5];
t[0] = _mm_add_ps(_mm_add_ps(s[0], s[5]), _mm_add_ps(s[10], s[15]));
t[1] = _mm_add_ps(_mm_add_ps(s[1], s[6]), _mm_add_ps(s[11], s[16]));
t[2] = _mm_add_ps(_mm_add_ps(s[2], s[7]), _mm_add_ps(s[12], s[17]));
t[3] = _mm_add_ps(_mm_add_ps(s[3], s[8]), _mm_add_ps(s[13], s[18]));
t[4] = _mm_add_ps(_mm_add_ps(s[4], s[9]), _mm_add_ps(s[14], s[19]));
dst[0] = _mm_add_ps(_mm_add_ps(t[0], t[1]), _mm_add_ps(t[2], t[3]));
dst[1] = _mm_add_ps(_mm_sub_ps(t[1], t[2]), _mm_mul_ps(_2, t[3]));
dst[2] = _mm_add_ps(_mm_add_ps(t[1], t[2]), _mm_add_ps(_mm_mul_ps(_4, t[3]), t[4]));
t[0] = _mm_add_ps(_mm_sub_ps(s[5], s[10]), _mm_mul_ps(_2, s[15]));
t[1] = _mm_add_ps(_mm_sub_ps(s[6], s[11]), _mm_mul_ps(_2, s[16]));
t[2] = _mm_add_ps(_mm_sub_ps(s[7], s[12]), _mm_mul_ps(_2, s[17]));
t[3] = _mm_add_ps(_mm_sub_ps(s[8], s[13]), _mm_mul_ps(_2, s[18]));
t[4] = _mm_add_ps(_mm_sub_ps(s[9], s[14]), _mm_mul_ps(_2, s[19]));
dst[3] = _mm_add_ps(_mm_add_ps(t[0], t[1]), _mm_add_ps(t[2], t[3]));
dst[4] = _mm_add_ps(_mm_sub_ps(t[1], t[2]), _mm_mul_ps(_2, t[3]));
dst[5] = _mm_add_ps(_mm_add_ps(t[1], t[2]), _mm_add_ps(_mm_mul_ps(_4, t[3]), t[4]));
t[0] = _mm_add_ps(_mm_add_ps(s[5], s[10]), _mm_add_ps(_mm_mul_ps(_4, s[15]), s[20]));
t[1] = _mm_add_ps(_mm_add_ps(s[6], s[11]), _mm_add_ps(_mm_mul_ps(_4, s[16]), s[21]));
t[2] = _mm_add_ps(_mm_add_ps(s[7], s[12]), _mm_add_ps(_mm_mul_ps(_4, s[17]), s[22]));
t[3] = _mm_add_ps(_mm_add_ps(s[8], s[13]), _mm_add_ps(_mm_mul_ps(_4, s[18]), s[23]));
t[4] = _mm_add_ps(_mm_add_ps(s[9], s[14]), _mm_add_ps(_mm_mul_ps(_4, s[19]), s[24]));
dst[6] = _mm_add_ps(_mm_add_ps(t[0], t[1]), _mm_add_ps(t[2], t[3]));
dst[7] = _mm_add_ps(_mm_sub_ps(t[1], t[2]), _mm_mul_ps(_2, t[3]));
dst[8] = _mm_add_ps(_mm_add_ps(t[1], t[2]), _mm_add_ps(_mm_mul_ps(_4, t[3]), t[4]));
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetOutputStore9(const __m128 src[9], float * dst, size_t dstS, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstS + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 0 * dstS + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 0 * dstS + 2 * dstC, src[2]);
_mm_storeu_ps(dst + 1 * dstS + 0 * dstC, src[3]);
_mm_storeu_ps(dst + 1 * dstS + 1 * dstC, src[4]);
_mm_storeu_ps(dst + 1 * dstS + 2 * dstC, src[5]);
_mm_storeu_ps(dst + 2 * dstS + 0 * dstC, src[6]);
_mm_storeu_ps(dst + 2 * dstS + 1 * dstC, src[7]);
_mm_storeu_ps(dst + 2 * dstS + 2 * dstC, src[8]);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[9];
WinogradKernel3x3Block3x3SetOutputLoad25(src + d, srcStride, tmp);
WinogradKernel3x3Block3x3SetOutputStore9(tmp, dst + d, dstS, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[9];
WinogradKernel3x3Block3x3SetOutputLoad25(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block3x3SetOutputStore9(tmp, dst + dstC - F, dstS, dstC);
}
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetOutputStore9(const __m128 src[16], float * dst, size_t dstS, size_t dstC, size_t rowE, size_t colE)
{
for (size_t row = 0; row < rowE; ++row)
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + row * dstS + col * dstC, src[row * 3 + col]);
}
SIMD_INLINE void WinogradKernel3x3Block3x3SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC, size_t rowE, size_t colE)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[9];
WinogradKernel3x3Block3x3SetOutputLoad25(src + d, srcStride, tmp);
WinogradKernel3x3Block3x3SetOutputStore9(tmp, dst + d, dstS, dstC, rowE, colE);
}
if (dstCF < dstC)
{
__m128 tmp[9];
WinogradKernel3x3Block3x3SetOutputLoad25(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block3x3SetOutputStore9(tmp, dst + dstC - F, dstS, dstC, rowE, colE);
}
}
void WinogradKernel3x3Block3x3SetOutput(const float * src, size_t srcStride, float * dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < 4) : (dstHeight < 3 || dstWidth < 12))
{
Base::WinogradKernel3x3Block3x3SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileH = (dstHeight + 2) / 3;
size_t tileW = (dstWidth + 2) / 3;
size_t dstH3 = AlignLoAny(dstHeight, 3);
size_t dstW3 = AlignLoAny(dstWidth, 3);
if (trans)
{
size_t row, col;
for (row = 0; row < dstH3; row += 3)
{
for (col = 0; col < dstW3; col += 3)
WinogradKernel3x3Block3x3SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block3x3SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, 3, dstWidth - col), src += dstChannels;
}
if (row < dstHeight)
{
for (col = 0; col < dstW3; col += 3)
WinogradKernel3x3Block3x3SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, 3), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block3x3SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, dstWidth - col), src += dstChannels;
}
}
else
{
Base::WinogradKernel3x3Block3x3SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block4x4SetFilter4Row(const __m128 * t, float * dst, size_t stride)
{
const __m128 r4 = _mm_set1_ps(1.0f / 4.0f);
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 mr6 = _mm_set1_ps(-1.0f / 6.0f);
const __m128 r12 = _mm_set1_ps(1.0f / 12.0f);
const __m128 r24 = _mm_set1_ps(1.0f / 24.0f);
_mm_storeu_ps(dst + 0 * stride, _mm_mul_ps(r4, t[0]));
__m128 t0 = _mm_add_ps(t[0], t[2]);
_mm_storeu_ps(dst + 1 * stride, _mm_mul_ps(mr6, _mm_add_ps(t0, t[1])));
_mm_storeu_ps(dst + 2 * stride, _mm_mul_ps(mr6, _mm_sub_ps(t0, t[1])));
__m128 t1 = _mm_add_ps(_mm_mul_ps(r24, t[0]), _mm_mul_ps(r6, t[2]));
__m128 t2 = _mm_mul_ps(r12, t[1]);
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(t1, t2));
_mm_storeu_ps(dst + 4 * stride, _mm_sub_ps(t1, t2));
_mm_storeu_ps(dst + 5 * stride, t[2]);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetFilter4All(const __m128 * s, float * dst, size_t stride)
{
const __m128 r4 = _mm_set1_ps(1.0f / 4.0f);
const __m128 r6 = _mm_set1_ps(1.0f / 6.0f);
const __m128 mr6 = _mm_set1_ps(-1.0f / 6.0f);
const __m128 r12 = _mm_set1_ps(1.0f / 12.0f);
const __m128 r24 = _mm_set1_ps(1.0f / 24.0f);
__m128 t[3];
t[0] = _mm_mul_ps(r4, s[0]);
t[1] = _mm_mul_ps(r4, s[1]);
t[2] = _mm_mul_ps(r4, s[2]);
WinogradKernel3x3Block4x4SetFilter4Row(t, dst + 0 * stride, stride);
t[0] = _mm_mul_ps(mr6, _mm_add_ps(_mm_add_ps(s[0], s[3]), s[6]));
t[1] = _mm_mul_ps(mr6, _mm_add_ps(_mm_add_ps(s[1], s[4]), s[7]));
t[2] = _mm_mul_ps(mr6, _mm_add_ps(_mm_add_ps(s[2], s[5]), s[8]));
WinogradKernel3x3Block4x4SetFilter4Row(t, dst + 6 * stride, stride);
t[0] = _mm_mul_ps(mr6, _mm_add_ps(_mm_sub_ps(s[0], s[3]), s[6]));
t[1] = _mm_mul_ps(mr6, _mm_add_ps(_mm_sub_ps(s[1], s[4]), s[7]));
t[2] = _mm_mul_ps(mr6, _mm_add_ps(_mm_sub_ps(s[2], s[5]), s[8]));
WinogradKernel3x3Block4x4SetFilter4Row(t, dst + 12 * stride, stride);
t[0] = _mm_add_ps(_mm_add_ps(_mm_mul_ps(r24, s[0]), _mm_mul_ps(r12, s[3])), _mm_mul_ps(r6, s[6]));
t[1] = _mm_add_ps(_mm_add_ps(_mm_mul_ps(r24, s[1]), _mm_mul_ps(r12, s[4])), _mm_mul_ps(r6, s[7]));
t[2] = _mm_add_ps(_mm_add_ps(_mm_mul_ps(r24, s[2]), _mm_mul_ps(r12, s[5])), _mm_mul_ps(r6, s[8]));
WinogradKernel3x3Block4x4SetFilter4Row(t, dst + 18 * stride, stride);
t[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(r24, s[0]), _mm_mul_ps(r12, s[3])), _mm_mul_ps(r6, s[6]));
t[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(r24, s[1]), _mm_mul_ps(r12, s[4])), _mm_mul_ps(r6, s[7]));
t[2] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(r24, s[2]), _mm_mul_ps(r12, s[5])), _mm_mul_ps(r6, s[8]));
WinogradKernel3x3Block4x4SetFilter4Row(t, dst + 24 * stride, stride);
WinogradKernel3x3Block4x4SetFilter4Row(s + 6, dst + 30 * stride, stride);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetFilter4n(const float * src, float * dst, size_t stride)
{
__m128 s[9];
Load4(src + 0, 9, s + 0);
Load4(src + 4, 9, s + 4);
s[8] = _mm_setr_ps(src[8], src[17], src[26], src[35]);
WinogradKernel3x3Block4x4SetFilter4All(s, dst + 0 * stride, stride);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetFilter4t(const float * src, float * dst, size_t stride)
{
__m128 s[9];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
WinogradKernel3x3Block4x4SetFilter4All(s, dst + 0 * stride, stride);
}
void WinogradKernel3x3Block4x4SetFilter(const float * src, size_t size, float * dst, SimdBool trans)
{
size_t size4 = AlignLo(size, 4), i = 0;
if (trans)
{
for (; i < size4; i += 4)
WinogradKernel3x3Block4x4SetFilter4t(src + i, dst + i, size);
for (; i < size; i += 1)
Base::WinogradKernel3x3Block4x4SetFilter1t(src + i, dst + i, size);
}
else
{
for (; i < size4; i += 4, src += 36, dst += 4)
WinogradKernel3x3Block4x4SetFilter4n(src, dst, size);
for (; i < size; i += 1, src += 9, dst += 1)
Base::WinogradKernel3x3Block4x4SetFilter1n(src, dst, size);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block4x4SetInput4Store(const __m128 src[36], float * dst, size_t stride)
{
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 _5 = _mm_set1_ps(5.0f);
__m128 tmp[36];
tmp[0] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[0]), _mm_mul_ps(_5, src[12])), src[24]);
tmp[1] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[1]), _mm_mul_ps(_5, src[13])), src[25]);
tmp[2] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[2]), _mm_mul_ps(_5, src[14])), src[26]);
tmp[3] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[3]), _mm_mul_ps(_5, src[15])), src[27]);
tmp[4] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[4]), _mm_mul_ps(_5, src[16])), src[28]);
tmp[5] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[5]), _mm_mul_ps(_5, src[17])), src[29]);
tmp[6] = _mm_sub_ps(_mm_add_ps(src[18], src[24]), _mm_mul_ps(_4, _mm_add_ps(src[6], src[12])));
tmp[7] = _mm_sub_ps(_mm_add_ps(src[19], src[25]), _mm_mul_ps(_4, _mm_add_ps(src[7], src[13])));
tmp[8] = _mm_sub_ps(_mm_add_ps(src[20], src[26]), _mm_mul_ps(_4, _mm_add_ps(src[8], src[14])));
tmp[9] = _mm_sub_ps(_mm_add_ps(src[21], src[27]), _mm_mul_ps(_4, _mm_add_ps(src[9], src[15])));
tmp[10] = _mm_sub_ps(_mm_add_ps(src[22], src[28]), _mm_mul_ps(_4, _mm_add_ps(src[10], src[16])));
tmp[11] = _mm_sub_ps(_mm_add_ps(src[23], src[29]), _mm_mul_ps(_4, _mm_add_ps(src[11], src[17])));
tmp[12] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[6], src[12])), _mm_sub_ps(src[24], src[18]));
tmp[13] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[7], src[13])), _mm_sub_ps(src[25], src[19]));
tmp[14] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[8], src[14])), _mm_sub_ps(src[26], src[20]));
tmp[15] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[9], src[15])), _mm_sub_ps(src[27], src[21]));
tmp[16] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[10], src[16])), _mm_sub_ps(src[28], src[22]));
tmp[17] = _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(src[11], src[17])), _mm_sub_ps(src[29], src[23]));
tmp[18] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[18], src[6])), _mm_sub_ps(src[24], src[12]));
tmp[19] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[19], src[7])), _mm_sub_ps(src[25], src[13]));
tmp[20] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[20], src[8])), _mm_sub_ps(src[26], src[14]));
tmp[21] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[21], src[9])), _mm_sub_ps(src[27], src[15]));
tmp[22] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[22], src[10])), _mm_sub_ps(src[28], src[16]));
tmp[23] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[23], src[11])), _mm_sub_ps(src[29], src[17]));
tmp[24] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[6], src[18])), _mm_sub_ps(src[24], src[12]));
tmp[25] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[7], src[19])), _mm_sub_ps(src[25], src[13]));
tmp[26] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[8], src[20])), _mm_sub_ps(src[26], src[14]));
tmp[27] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[9], src[21])), _mm_sub_ps(src[27], src[15]));
tmp[28] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[10], src[22])), _mm_sub_ps(src[28], src[16]));
tmp[29] = _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(src[11], src[23])), _mm_sub_ps(src[29], src[17]));
tmp[30] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[6]), _mm_mul_ps(_5, src[18])), src[30]);
tmp[31] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[7]), _mm_mul_ps(_5, src[19])), src[31]);
tmp[32] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[8]), _mm_mul_ps(_5, src[20])), src[32]);
tmp[33] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[9]), _mm_mul_ps(_5, src[21])), src[33]);
tmp[34] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[10]), _mm_mul_ps(_5, src[22])), src[34]);
tmp[35] = _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, src[11]), _mm_mul_ps(_5, src[23])), src[35]);
_mm_storeu_ps(dst + 0 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[0]), _mm_mul_ps(_5, tmp[2])), tmp[4]));
_mm_storeu_ps(dst + 1 * stride, _mm_sub_ps(_mm_add_ps(tmp[3], tmp[4]), _mm_mul_ps(_4, _mm_add_ps(tmp[1], tmp[2]))));
_mm_storeu_ps(dst + 2 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[1], tmp[2])), _mm_sub_ps(tmp[4], tmp[3])));
_mm_storeu_ps(dst + 3 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[3], tmp[1])), _mm_sub_ps(tmp[4], tmp[2])));
_mm_storeu_ps(dst + 4 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[1], tmp[3])), _mm_sub_ps(tmp[4], tmp[2])));
_mm_storeu_ps(dst + 5 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[1]), _mm_mul_ps(_5, tmp[3])), tmp[5]));
_mm_storeu_ps(dst + 6 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[6]), _mm_mul_ps(_5, tmp[8])), tmp[10]));
_mm_storeu_ps(dst + 7 * stride, _mm_sub_ps(_mm_add_ps(tmp[9], tmp[10]), _mm_mul_ps(_4, _mm_add_ps(tmp[7], tmp[8]))));
_mm_storeu_ps(dst + 8 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[7], tmp[8])), _mm_sub_ps(tmp[10], tmp[9])));
_mm_storeu_ps(dst + 9 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[9], tmp[7])), _mm_sub_ps(tmp[10], tmp[8])));
_mm_storeu_ps(dst + 10 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[7], tmp[9])), _mm_sub_ps(tmp[10], tmp[8])));
_mm_storeu_ps(dst + 11 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[7]), _mm_mul_ps(_5, tmp[9])), tmp[11]));
_mm_storeu_ps(dst + 12 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[12]), _mm_mul_ps(_5, tmp[14])), tmp[16]));
_mm_storeu_ps(dst + 13 * stride, _mm_sub_ps(_mm_add_ps(tmp[15], tmp[16]), _mm_mul_ps(_4, _mm_add_ps(tmp[13], tmp[14]))));
_mm_storeu_ps(dst + 14 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[13], tmp[14])), _mm_sub_ps(tmp[16], tmp[15])));
_mm_storeu_ps(dst + 15 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[15], tmp[13])), _mm_sub_ps(tmp[16], tmp[14])));
_mm_storeu_ps(dst + 16 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[13], tmp[15])), _mm_sub_ps(tmp[16], tmp[14])));
_mm_storeu_ps(dst + 17 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[13]), _mm_mul_ps(_5, tmp[15])), tmp[17]));
_mm_storeu_ps(dst + 18 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[18]), _mm_mul_ps(_5, tmp[20])), tmp[22]));
_mm_storeu_ps(dst + 19 * stride, _mm_sub_ps(_mm_add_ps(tmp[21], tmp[22]), _mm_mul_ps(_4, _mm_add_ps(tmp[19], tmp[20]))));
_mm_storeu_ps(dst + 20 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[19], tmp[20])), _mm_sub_ps(tmp[22], tmp[21])));
_mm_storeu_ps(dst + 21 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[21], tmp[19])), _mm_sub_ps(tmp[22], tmp[20])));
_mm_storeu_ps(dst + 22 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[19], tmp[21])), _mm_sub_ps(tmp[22], tmp[20])));
_mm_storeu_ps(dst + 23 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[19]), _mm_mul_ps(_5, tmp[21])), tmp[23]));
_mm_storeu_ps(dst + 24 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[24]), _mm_mul_ps(_5, tmp[26])), tmp[28]));
_mm_storeu_ps(dst + 25 * stride, _mm_sub_ps(_mm_add_ps(tmp[27], tmp[28]), _mm_mul_ps(_4, _mm_add_ps(tmp[25], tmp[26]))));
_mm_storeu_ps(dst + 26 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[25], tmp[26])), _mm_sub_ps(tmp[28], tmp[27])));
_mm_storeu_ps(dst + 27 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[27], tmp[25])), _mm_sub_ps(tmp[28], tmp[26])));
_mm_storeu_ps(dst + 28 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[25], tmp[27])), _mm_sub_ps(tmp[28], tmp[26])));
_mm_storeu_ps(dst + 29 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[25]), _mm_mul_ps(_5, tmp[27])), tmp[29]));
_mm_storeu_ps(dst + 30 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[30]), _mm_mul_ps(_5, tmp[32])), tmp[34]));
_mm_storeu_ps(dst + 31 * stride, _mm_sub_ps(_mm_add_ps(tmp[33], tmp[34]), _mm_mul_ps(_4, _mm_add_ps(tmp[31], tmp[32]))));
_mm_storeu_ps(dst + 32 * stride, _mm_add_ps(_mm_mul_ps(_4, _mm_sub_ps(tmp[31], tmp[32])), _mm_sub_ps(tmp[34], tmp[33])));
_mm_storeu_ps(dst + 33 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[33], tmp[31])), _mm_sub_ps(tmp[34], tmp[32])));
_mm_storeu_ps(dst + 34 * stride, _mm_add_ps(_mm_mul_ps(_2, _mm_sub_ps(tmp[31], tmp[33])), _mm_sub_ps(tmp[34], tmp[32])));
_mm_storeu_ps(dst + 35 * stride, _mm_add_ps(_mm_sub_ps(_mm_mul_ps(_4, tmp[31]), _mm_mul_ps(_5, tmp[33])), tmp[35]));
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetInput4t(const float * src, size_t srcS, size_t srcC, __m128 dst[36])
{
dst[0] = _mm_loadu_ps(src + 0 * srcS + 0 * srcC);
dst[1] = _mm_loadu_ps(src + 0 * srcS + 1 * srcC);
dst[2] = _mm_loadu_ps(src + 0 * srcS + 2 * srcC);
dst[3] = _mm_loadu_ps(src + 0 * srcS + 3 * srcC);
dst[4] = _mm_loadu_ps(src + 0 * srcS + 4 * srcC);
dst[5] = _mm_loadu_ps(src + 0 * srcS + 5 * srcC);
dst[6] = _mm_loadu_ps(src + 1 * srcS + 0 * srcC);
dst[7] = _mm_loadu_ps(src + 1 * srcS + 1 * srcC);
dst[8] = _mm_loadu_ps(src + 1 * srcS + 2 * srcC);
dst[9] = _mm_loadu_ps(src + 1 * srcS + 3 * srcC);
dst[10] = _mm_loadu_ps(src + 1 * srcS + 4 * srcC);
dst[11] = _mm_loadu_ps(src + 1 * srcS + 5 * srcC);
dst[12] = _mm_loadu_ps(src + 2 * srcS + 0 * srcC);
dst[13] = _mm_loadu_ps(src + 2 * srcS + 1 * srcC);
dst[14] = _mm_loadu_ps(src + 2 * srcS + 2 * srcC);
dst[15] = _mm_loadu_ps(src + 2 * srcS + 3 * srcC);
dst[16] = _mm_loadu_ps(src + 2 * srcS + 4 * srcC);
dst[17] = _mm_loadu_ps(src + 2 * srcS + 5 * srcC);
dst[18] = _mm_loadu_ps(src + 3 * srcS + 0 * srcC);
dst[19] = _mm_loadu_ps(src + 3 * srcS + 1 * srcC);
dst[20] = _mm_loadu_ps(src + 3 * srcS + 2 * srcC);
dst[21] = _mm_loadu_ps(src + 3 * srcS + 3 * srcC);
dst[22] = _mm_loadu_ps(src + 3 * srcS + 4 * srcC);
dst[23] = _mm_loadu_ps(src + 3 * srcS + 5 * srcC);
dst[24] = _mm_loadu_ps(src + 4 * srcS + 0 * srcC);
dst[25] = _mm_loadu_ps(src + 4 * srcS + 1 * srcC);
dst[26] = _mm_loadu_ps(src + 4 * srcS + 2 * srcC);
dst[27] = _mm_loadu_ps(src + 4 * srcS + 3 * srcC);
dst[28] = _mm_loadu_ps(src + 4 * srcS + 4 * srcC);
dst[29] = _mm_loadu_ps(src + 4 * srcS + 5 * srcC);
dst[30] = _mm_loadu_ps(src + 5 * srcS + 0 * srcC);
dst[31] = _mm_loadu_ps(src + 5 * srcS + 1 * srcC);
dst[32] = _mm_loadu_ps(src + 5 * srcS + 2 * srcC);
dst[33] = _mm_loadu_ps(src + 5 * srcS + 3 * srcC);
dst[34] = _mm_loadu_ps(src + 5 * srcS + 4 * srcC);
dst[35] = _mm_loadu_ps(src + 5 * srcS + 5 * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetInput4t(const float * src, size_t srcW, size_t srcC, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[36];
WinogradKernel3x3Block4x4SetInput4t(src + c, srcS, srcC, tmp);
WinogradKernel3x3Block4x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[36];
WinogradKernel3x3Block4x4SetInput4t(src + srcC - F, srcS, srcC, tmp);
WinogradKernel3x3Block4x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetInput4t(const float * src, size_t srcS, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, __m128 dst[36])
{
for (size_t i = 0; i < 36; ++i)
dst[i] = _mm_setzero_ps();
for (size_t row = rowB; row < rowE; ++row)
for (size_t col = colB; col < colE; ++col)
dst[row * 6 + col] = _mm_loadu_ps(src + row * srcS + col * srcC);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetInput4t(const float * src, size_t srcW, size_t srcC, size_t rowB, size_t rowE, size_t colB, size_t colE, float * dst, size_t dstStride)
{
size_t srcS = srcW * srcC;
size_t srcCF = AlignLo(srcC, F);
for (size_t c = 0; c < srcCF; c += F)
{
__m128 tmp[36];
WinogradKernel3x3Block4x4SetInput4t(src + c, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block4x4SetInput4Store(tmp, dst + c, dstStride);
}
if (srcCF < srcC)
{
__m128 tmp[36];
WinogradKernel3x3Block4x4SetInput4t(src + srcC - F, srcS, srcC, rowB, rowE, colB, colE, tmp);
WinogradKernel3x3Block4x4SetInput4Store(tmp, dst + srcC - F, dstStride);
}
}
void WinogradKernel3x3Block4x4SetInput(const float* src, size_t srcChannels, size_t srcHeight, size_t srcWidth,
size_t padY, size_t padX, size_t padH, size_t padW, float* dst, size_t dstStride, SimdBool trans)
{
if (trans ? (srcChannels < 4) : (srcHeight < 6 || srcWidth < 12))
{
Base::WinogradKernel3x3Block4x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
return;
}
if (trans)
{
assert(padY + padH <= 2 && padX + padW <= 2);
size_t dstH = srcHeight - 2 + padY + padH;
size_t dstW = srcWidth - 2 + padX + padW;
size_t dstH4 = dstH / 4 * 4;
size_t dstW4 = dstW / 4 * 4;
size_t noseW = Simd::Min<size_t>(6, srcWidth + padX);
size_t noseH = Simd::Min<size_t>(6, srcHeight + padY);
size_t startY = padY ? 4 : 0;
size_t startX = padX ? 4 : 0;
if (padH && dstH == dstH4)
dstH4 -= 4;
if (padY)
src -= srcWidth * srcChannels;
if (padW && dstW == dstW4)
dstW4 -= 4;
if (padX)
src -= srcChannels;
size_t tailW = dstW - dstW4 + (padW ? 1 : 2);
size_t tailH = dstH - dstH4 + (padH ? 1 : 2);
size_t row = 0, col = 0;
if (padY)
{
if (padX)
WinogradKernel3x3Block4x4SetInput4t(src, srcWidth, srcChannels, 1, noseH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel3x3Block4x4SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, 6, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block4x4SetInput4t(src + col * srcChannels, srcWidth, srcChannels, 1, noseH, 0, tailW, dst, dstStride), dst += srcChannels;
}
for (row = startY; row < dstH4; row += 4)
{
if (padX)
WinogradKernel3x3Block4x4SetInput4t(src + row * srcWidth * srcChannels, srcWidth, srcChannels, 0, 6, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel3x3Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, 6, 0, tailW, dst, dstStride), dst += srcChannels;
}
if (row < dstH)
{
if (padX)
WinogradKernel3x3Block4x4SetInput4t(src + row * srcWidth* srcChannels, srcWidth, srcChannels, 0, tailH, 1, noseW, dst, dstStride), dst += srcChannels;
for (col = startX; col < dstW4; col += 4)
WinogradKernel3x3Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, 6, dst, dstStride), dst += srcChannels;
if (col < dstW)
WinogradKernel3x3Block4x4SetInput4t(src + (row * srcWidth + col) * srcChannels, srcWidth, srcChannels, 0, tailH, 0, tailW, dst, dstStride), dst += srcChannels;
}
}
else
{
Base::WinogradKernel3x3Block4x4SetInput(src, srcChannels, srcHeight, srcWidth, padY, padX, padH, padW, dst, dstStride, trans);
}
}
//-----------------------------------------------------------------------
SIMD_INLINE void WinogradKernel3x3Block4x4SetOutputLoad36(const float * src, size_t stride, __m128 dst[16])
{
__m128 s[36];
s[0] = _mm_loadu_ps(src + 0 * stride);
s[1] = _mm_loadu_ps(src + 1 * stride);
s[2] = _mm_loadu_ps(src + 2 * stride);
s[3] = _mm_loadu_ps(src + 3 * stride);
s[4] = _mm_loadu_ps(src + 4 * stride);
s[5] = _mm_loadu_ps(src + 5 * stride);
s[6] = _mm_loadu_ps(src + 6 * stride);
s[7] = _mm_loadu_ps(src + 7 * stride);
s[8] = _mm_loadu_ps(src + 8 * stride);
s[9] = _mm_loadu_ps(src + 9 * stride);
s[10] = _mm_loadu_ps(src + 10 * stride);
s[11] = _mm_loadu_ps(src + 11 * stride);
s[12] = _mm_loadu_ps(src + 12 * stride);
s[13] = _mm_loadu_ps(src + 13 * stride);
s[14] = _mm_loadu_ps(src + 14 * stride);
s[15] = _mm_loadu_ps(src + 15 * stride);
s[16] = _mm_loadu_ps(src + 16 * stride);
s[17] = _mm_loadu_ps(src + 17 * stride);
s[18] = _mm_loadu_ps(src + 18 * stride);
s[19] = _mm_loadu_ps(src + 19 * stride);
s[20] = _mm_loadu_ps(src + 20 * stride);
s[21] = _mm_loadu_ps(src + 21 * stride);
s[22] = _mm_loadu_ps(src + 22 * stride);
s[23] = _mm_loadu_ps(src + 23 * stride);
s[24] = _mm_loadu_ps(src + 24 * stride);
s[25] = _mm_loadu_ps(src + 25 * stride);
s[26] = _mm_loadu_ps(src + 26 * stride);
s[27] = _mm_loadu_ps(src + 27 * stride);
s[28] = _mm_loadu_ps(src + 28 * stride);
s[29] = _mm_loadu_ps(src + 29 * stride);
s[30] = _mm_loadu_ps(src + 30 * stride);
s[31] = _mm_loadu_ps(src + 31 * stride);
s[32] = _mm_loadu_ps(src + 32 * stride);
s[33] = _mm_loadu_ps(src + 33 * stride);
s[34] = _mm_loadu_ps(src + 34 * stride);
s[35] = _mm_loadu_ps(src + 35 * stride);
__m128 _2 = _mm_set1_ps(2.0f);
__m128 _4 = _mm_set1_ps(4.0f);
__m128 _8 = _mm_set1_ps(8.0f);
__m128 t[24];
t[0] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[0], s[6]), _mm_add_ps(s[12], s[18])), s[24]);
t[1] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[1], s[7]), _mm_add_ps(s[13], s[19])), s[25]);
t[2] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[2], s[8]), _mm_add_ps(s[14], s[20])), s[26]);
t[3] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[3], s[9]), _mm_add_ps(s[15], s[21])), s[27]);
t[4] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[4], s[10]), _mm_add_ps(s[16], s[22])), s[28]);
t[5] = _mm_add_ps(_mm_add_ps(_mm_add_ps(s[5], s[11]), _mm_add_ps(s[17], s[23])), s[29]);
t[6] = _mm_add_ps(_mm_sub_ps(s[6], s[12]), _mm_mul_ps(_2, _mm_sub_ps(s[18], s[24])));
t[7] = _mm_add_ps(_mm_sub_ps(s[7], s[13]), _mm_mul_ps(_2, _mm_sub_ps(s[19], s[25])));
t[8] = _mm_add_ps(_mm_sub_ps(s[8], s[14]), _mm_mul_ps(_2, _mm_sub_ps(s[20], s[26])));
t[9] = _mm_add_ps(_mm_sub_ps(s[9], s[15]), _mm_mul_ps(_2, _mm_sub_ps(s[21], s[27])));
t[10] = _mm_add_ps(_mm_sub_ps(s[10], s[16]), _mm_mul_ps(_2, _mm_sub_ps(s[22], s[28])));
t[11] = _mm_add_ps(_mm_sub_ps(s[11], s[17]), _mm_mul_ps(_2, _mm_sub_ps(s[23], s[29])));
t[12] = _mm_add_ps(_mm_add_ps(s[6], s[12]), _mm_mul_ps(_4, _mm_add_ps(s[18], s[24])));
t[13] = _mm_add_ps(_mm_add_ps(s[7], s[13]), _mm_mul_ps(_4, _mm_add_ps(s[19], s[25])));
t[14] = _mm_add_ps(_mm_add_ps(s[8], s[14]), _mm_mul_ps(_4, _mm_add_ps(s[20], s[26])));
t[15] = _mm_add_ps(_mm_add_ps(s[9], s[15]), _mm_mul_ps(_4, _mm_add_ps(s[21], s[27])));
t[16] = _mm_add_ps(_mm_add_ps(s[10], s[16]), _mm_mul_ps(_4, _mm_add_ps(s[22], s[28])));
t[17] = _mm_add_ps(_mm_add_ps(s[11], s[17]), _mm_mul_ps(_4, _mm_add_ps(s[23], s[29])));
t[18] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[6], s[12]), _mm_mul_ps(_8, _mm_sub_ps(s[18], s[24]))), s[30]);
t[19] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[7], s[13]), _mm_mul_ps(_8, _mm_sub_ps(s[19], s[25]))), s[31]);
t[20] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[8], s[14]), _mm_mul_ps(_8, _mm_sub_ps(s[20], s[26]))), s[32]);
t[21] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[9], s[15]), _mm_mul_ps(_8, _mm_sub_ps(s[21], s[27]))), s[33]);
t[22] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[10], s[16]), _mm_mul_ps(_8, _mm_sub_ps(s[22], s[28]))), s[34]);
t[23] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(s[11], s[17]), _mm_mul_ps(_8, _mm_sub_ps(s[23], s[29]))), s[35]);
dst[0] = _mm_add_ps(_mm_add_ps(_mm_add_ps(t[0], t[1]), _mm_add_ps(t[2], t[3])), t[4]);
dst[1] = _mm_add_ps(_mm_sub_ps(t[1], t[2]), _mm_mul_ps(_2, _mm_sub_ps(t[3], t[4])));
dst[2] = _mm_add_ps(_mm_add_ps(t[1], t[2]), _mm_mul_ps(_4, _mm_add_ps(t[3], t[4])));
dst[3] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(t[1], t[2]), _mm_mul_ps(_8, _mm_sub_ps(t[3], t[4]))), t[5]);
dst[4] = _mm_add_ps(_mm_add_ps(_mm_add_ps(t[6], t[7]), _mm_add_ps(t[8], t[9])), t[10]);
dst[5] = _mm_add_ps(_mm_sub_ps(t[7], t[8]), _mm_mul_ps(_2, _mm_sub_ps(t[9], t[10])));
dst[6] = _mm_add_ps(_mm_add_ps(t[7], t[8]), _mm_mul_ps(_4, _mm_add_ps(t[9], t[10])));
dst[7] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(t[7], t[8]), _mm_mul_ps(_8, _mm_sub_ps(t[9], t[10]))), t[11]);
dst[8] = _mm_add_ps(_mm_add_ps(_mm_add_ps(t[12], t[13]), _mm_add_ps(t[14], t[15])), t[16]);
dst[9] = _mm_add_ps(_mm_sub_ps(t[13], t[14]), _mm_mul_ps(_2, _mm_sub_ps(t[15], t[16])));
dst[10] = _mm_add_ps(_mm_add_ps(t[13], t[14]), _mm_mul_ps(_4, _mm_add_ps(t[15], t[16])));
dst[11] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(t[13], t[14]), _mm_mul_ps(_8, _mm_sub_ps(t[15], t[16]))), t[17]);
dst[12] = _mm_add_ps(_mm_add_ps(_mm_add_ps(t[18], t[19]), _mm_add_ps(t[20], t[21])), t[22]);
dst[13] = _mm_add_ps(_mm_sub_ps(t[19], t[20]), _mm_mul_ps(_2, _mm_sub_ps(t[21], t[22])));
dst[14] = _mm_add_ps(_mm_add_ps(t[19], t[20]), _mm_mul_ps(_4, _mm_add_ps(t[21], t[22])));
dst[15] = _mm_add_ps(_mm_add_ps(_mm_sub_ps(t[19], t[20]), _mm_mul_ps(_8, _mm_sub_ps(t[21], t[22]))), t[23]);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetOutputStore16(const __m128 src[16], float * dst, size_t dstS, size_t dstC)
{
_mm_storeu_ps(dst + 0 * dstS + 0 * dstC, src[0]);
_mm_storeu_ps(dst + 0 * dstS + 1 * dstC, src[1]);
_mm_storeu_ps(dst + 0 * dstS + 2 * dstC, src[2]);
_mm_storeu_ps(dst + 0 * dstS + 3 * dstC, src[3]);
_mm_storeu_ps(dst + 1 * dstS + 0 * dstC, src[4]);
_mm_storeu_ps(dst + 1 * dstS + 1 * dstC, src[5]);
_mm_storeu_ps(dst + 1 * dstS + 2 * dstC, src[6]);
_mm_storeu_ps(dst + 1 * dstS + 3 * dstC, src[7]);
_mm_storeu_ps(dst + 2 * dstS + 0 * dstC, src[8]);
_mm_storeu_ps(dst + 2 * dstS + 1 * dstC, src[9]);
_mm_storeu_ps(dst + 2 * dstS + 2 * dstC, src[10]);
_mm_storeu_ps(dst + 2 * dstS + 3 * dstC, src[11]);
_mm_storeu_ps(dst + 3 * dstS + 0 * dstC, src[12]);
_mm_storeu_ps(dst + 3 * dstS + 1 * dstC, src[13]);
_mm_storeu_ps(dst + 3 * dstS + 2 * dstC, src[14]);
_mm_storeu_ps(dst + 3 * dstS + 3 * dstC, src[15]);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[16];
WinogradKernel3x3Block4x4SetOutputLoad36(src + d, srcStride, tmp);
WinogradKernel3x3Block4x4SetOutputStore16(tmp, dst + d, dstS, dstC);
}
if (dstCF < dstC)
{
__m128 tmp[16];
WinogradKernel3x3Block4x4SetOutputLoad36(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block4x4SetOutputStore16(tmp, dst + dstC - F, dstS, dstC);
}
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetOutputStore16(const __m128 src[16], float * dst, size_t dstS, size_t dstC, size_t rowE, size_t colE)
{
for (size_t row = 0; row < rowE; ++row)
for (size_t col = 0; col < colE; ++col)
_mm_storeu_ps(dst + row * dstS + col * dstC, src[row * 4 + col]);
}
SIMD_INLINE void WinogradKernel3x3Block4x4SetOutput4t(const float * src, size_t srcStride, float * dst, size_t dstW, size_t dstC, size_t rowE, size_t colE)
{
size_t dstS = dstW * dstC, dstCF = AlignLo(dstC, F);
for (size_t d = 0; d < dstCF; d += F)
{
__m128 tmp[16];
WinogradKernel3x3Block4x4SetOutputLoad36(src + d, srcStride, tmp);
WinogradKernel3x3Block4x4SetOutputStore16(tmp, dst + d, dstS, dstC, rowE, colE);
}
if (dstCF < dstC)
{
__m128 tmp[16];
WinogradKernel3x3Block4x4SetOutputLoad36(src + dstC - F, srcStride, tmp);
WinogradKernel3x3Block4x4SetOutputStore16(tmp, dst + dstC - F, dstS, dstC, rowE, colE);
}
}
void WinogradKernel3x3Block4x4SetOutput(const float * src, size_t srcStride, float * dst, size_t dstChannels, size_t dstHeight, size_t dstWidth, SimdBool trans)
{
if (trans ? (dstChannels < 4) : (dstHeight < 4 || dstWidth < 16))
{
Base::WinogradKernel3x3Block4x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
return;
}
size_t tileH = (dstHeight + 3) / 4;
size_t tileW = (dstWidth + 3) / 4;
size_t dstH4 = AlignLo(dstHeight, 4);
size_t dstW4 = AlignLo(dstWidth, 4);
if (trans)
{
size_t row, col;
for (row = 0; row < dstH4; row += 4)
{
for (col = 0; col < dstW4; col += 4)
WinogradKernel3x3Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, 4, dstWidth - col), src += dstChannels;
}
if (row < dstHeight)
{
for (col = 0; col < dstW4; col += 4)
WinogradKernel3x3Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, 4), src += dstChannels;
if (col < dstWidth)
WinogradKernel3x3Block4x4SetOutput4t(src, srcStride, dst + (row * dstWidth + col)*dstChannels, dstWidth, dstChannels, dstHeight - row, dstWidth - col), src += dstChannels;
}
}
else
{
Base::WinogradKernel3x3Block4x4SetOutput(src, srcStride, dst, dstChannels, dstHeight, dstWidth, trans);
}
}
}
#endif// SIMD_SSE_ENABLE
}
| [
"[email protected]"
] | |
d55749546c949c65c24c3156d076e6e2196f088f | 5410981c017968306cb42c709b0b77174bb539f5 | /CSC3222/CSC3222Coursework 2020 2021/RigidBody.h | fd9b972be3a1c570cfa722723edb9b676b9cb8c8 | [] | no_license | JackGHopkins/CSC3222---Game-Simulations | d16ec2cc633a187e28222d0f9be6cd21cdaf569d | fa0f71443d25b1add3199802e7ba11663395819e | refs/heads/master | 2023-05-05T18:04:01.934537 | 2021-05-26T00:00:18 | 2021-05-26T00:00:18 | 337,052,482 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,607 | h | #pragma once
#include "../../Common/Vector2.h"
namespace NCL {
using namespace Maths;
namespace CSC3222 {
class RigidBody {
friend class GameSimsPhysics;
public:
RigidBody();
~RigidBody();
Vector2 GetPosition() const {
return position;
}
void SetPosition(const Vector2& newPosition) {
position = newPosition;
}
Vector2 GetVelocity() const {
return velocity;
}
void SetVelocity(const Vector2& newVelocity) {
velocity = newVelocity;
}
Vector2 GetForce() const {
return force;
}
void SetForce(const Vector2& newForce) {
force = newForce;
}
float GetInverseMass() const {
return inverseMass;
}
void AddForce(const Vector2& newForce) {
force += newForce;
}
void AddProjection(const Vector2& collisionNormal, const float penetration, const float o2InverseMass) {
position += -collisionNormal * penetration * (inverseMass / (inverseMass + o2InverseMass));
}
void AddImpluse(const Vector2& v1, const Vector2& v2, const float o2InverseMass) {
/*
-(1+e) * (v1 - v2) * Normalised Collision Pair
J = ______________________________________________
(inverse mass A + invers mass B)
vA = vA - inverse mA * J * normalised Collision Pair
vB = vB - inverse mB * J * normalised Collision Pair
*/
float impluse = ((-(1 + elasticity)) * Vector2::Dot(v1, v2) / (inverseMass + o2InverseMass));
velocity += v2 * inverseMass * impluse;
}
protected:
Vector2 position;
Vector2 velocity;
Vector2 force;
float inverseMass;
float elasticity;
};
}
}
| [
"[email protected]"
] | |
f57db94ad78dc6aefd19bfe3f895faea03c15add | c23f0748ae0f464cea4be2ffa9c456163a7f7e02 | /arrays_string/rev.cpp | ecf70466cf4458e3265b8fcfb0b965288d330b4a | [] | no_license | arp5/crackingthecodinginterview | 86e9aad29beec82f4bf6340448bc4dd84dc35c36 | 2195883f0bf68116bedf3571d56fe963c5b4867c | refs/heads/master | 2021-04-28T21:34:17.296927 | 2017-01-01T06:57:55 | 2017-01-01T06:57:55 | 77,769,041 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 314 | cpp | //Write code to reverse a C-Style String. (C-String means that “abcd” is represented as
//!ve characters, including the null character.)
#include<iostream>
using namespace std;
void revstrC(string s){}
int main(){
char mystr[]="arpita";
//mystr = "star";
mystr[3] = 1;
cout << mystr<< endl;
return 0;
} | [
"[email protected]"
] | |
dcbe12e9e7447ded4d9009a14f26f81e68a093bd | 78e7cd17efe19cc61a09efcbf63c4f83ad0c24e2 | /physics-baccarat_copy/generator/include/BaccGeneratorXe129m.hh | 51e7e8beb444af6d0feb50a9dbca7a65be614f23 | [] | no_license | bglenardo/CNG | 8ac15269b5e741ea4b4a714d3e62cc0691483eaa | ea98b55604a74c59216cbd04161d89592cf57e76 | refs/heads/master | 2020-05-31T04:34:44.208252 | 2015-12-03T00:29:34 | 2015-12-03T00:29:34 | 22,165,976 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,213 | hh | ////////////////////////////////////////////////////////////////////////////////
/* BaccGeneratorXe129m.hh
This is the header file for the Xe129m generator.
********************************************************************************
Change log
2013/11/20 - Initial submission (Vic)
*/
////////////////////////////////////////////////////////////////////////////////
#ifndef BaccGeneratorXe129m_HH
#define BaccGeneratorXe129m_HH 1
//
// GEANT4 includes
//
#include "G4ParticleDefinition.hh"
#include "globals.hh"
//
// Bacc includes
//
#include "BaccSource.hh"
//------++++++------++++++------++++++------++++++------++++++------++++++------
class BaccGeneratorXe129m : public BaccSource
{
public:
BaccGeneratorXe129m();
~BaccGeneratorXe129m();
public:
using BaccSource::GenerateEventList;
void GenerateEventList( G4ThreeVector, G4int, G4int, G4double );
using BaccSource::GenerateFromEventList;
void GenerateFromEventList(G4GeneralParticleSource*,G4Event*,decayNode*);
//using BaccSource::GenerateEvent;
//void GenerateEvent( G4GeneralParticleSource*, G4Event* );
private:
G4ParticleDefinition *ion;
G4ParticleDefinition *gammaDef;
};
#endif
| [
"[email protected]"
] | |
772ae0b4dc1041a47eb8abf310c8de08ed0793b4 | d0276045ff88c6ad4969aa4deb929d1e2ed9efb7 | /Striver SDE SHEET/Day 3 (Arrays and Maths)/Reverse Pairs.cpp | 050ed168df715e27715f1c7c76b5f6b3cbf64b6f | [] | no_license | rishabhtyagi2306/Competitive-Programming | 2f4d6e34701d3012832e908341606fa0501173a4 | 269d42a89940eefa73c922b6f275596fe68add6a | refs/heads/master | 2023-07-12T18:05:17.366652 | 2021-08-29T18:30:09 | 2021-08-29T18:30:09 | 256,992,147 | 3 | 3 | null | 2020-10-02T05:43:31 | 2020-04-19T12:20:46 | C++ | UTF-8 | C++ | false | false | 1,503 | cpp | class Solution {
public:
void merge(vector<int> &a, int l, int mid, int r, int &ans)
{
int n = mid-l+1;
int m = r-mid;
int left[n], right[m];
int i, j, k;
for(i = 0; i < n; i++)
{
left[i] = a[i+l];
}
for(i = 0; i < m; i++)
{
right[i] = a[i+mid+1];
}
i = j = 0;
k = l;
while(i < n && j < m)
{
if((long long)left[i] > 2ll * right[j])
{
ans += (n - i);
j++;
}
else
{
i++;
}
}
i = j = 0;
while(i < n && j < m)
{
if(left[i] <= right[j])
{
a[k++] = left[i++];
}
else
{
a[k++] = right[j++];
}
}
while(i < n)
{
a[k++] = left[i++];
}
while(j < m)
{
a[k++] = right[j++];
}
}
void mergeSort(vector<int> &a, int l, int r, int &ans)
{
if(l >= r)
return ;
int mid = (l + r)/2;
mergeSort(a, l, mid, ans);
mergeSort(a, mid+1, r, ans);
merge(a, l, mid, r, ans);
}
int reversePairs(vector<int>& nums) {
int n = nums.size();
int ans = 0;
mergeSort(nums, 0, n-1, ans);
return ans;
}
}; | [
"[email protected]"
] | |
3ded3efcb080c80605e59ccd381baae913c567a0 | c86123c9dd3ed755029d61d57df0408fe3f67192 | /entities/bullet.cpp | 5d0f7bc535e111894be0948f710e5440ec2b0c60 | [] | no_license | Przemekkkth/Qt-C-SimpleGame | a894f88849a4ca225edd2af7c3b23059dadf63ff | 299966a49b7f057c2b1837ce702dde9fd4d8b866 | refs/heads/master | 2020-04-25T12:00:00.065361 | 2019-06-01T17:27:39 | 2019-06-01T17:27:39 | 172,764,026 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,691 | cpp | #include "bullet.h"
#include <QGraphicsScene>
#include "tools/sprite.h"
#include "bluebackground.h"
#include "tools/config.h"
#include "evil1.h"
#include "wall.h"
#include <QDebug>
static const double Pi = 3.14159265358979323846264338327950288419717;
static double TwoPi = 2.0 * Pi;
static qreal normalizeAngle(qreal angle)
{
while (angle < 0)
angle += TwoPi;
while (angle > TwoPi)
angle -= TwoPi;
return angle;
}
Bullet::Bullet(QPointF start, QGraphicsItem * hero, qreal rotation, QObject *parent) : QObject(parent)
{
this->hero = hero;
setRotation(rotation);
setPos(start);
timerBullet = new QTimer();
connect(timerBullet, &QTimer::timeout, this, &Bullet::slotTimerBullet);
timerBullet->start(7);
}
QRectF Bullet::boundingRect() const
{
return QRectF(0, 0, 2, 4);
}
void Bullet::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/ , QWidget */*widget*/)
{
painter->setRenderHint(QPainter::Antialiasing);
painter->setPen(Qt::black);
painter->setBrush(Qt::black);
painter->drawRect(0, 0, 2, 4);
}
void Bullet::slotTimerBullet()
{
setPos(mapToParent(0, -10));
QList<QGraphicsItem *> foundItems = scene()->items(QPolygonF()
<< mapToScene(0, 0)
<< mapToScene(-1, -1)
<< mapToScene(1, -1));
foreach (QGraphicsItem *item, foundItems) {
if (item == this || item == hero || item->type() == (UserType + 1) )
{
continue;
}
//Evil1 || Ground || Brick
else if(item->type() == GroundType || item->type() == BrickType || item->type() == WallType)
{
scene()->addItem(new Sprite(pos()));
deleteLater();
}
else if(item->type() == Evil1Type)
{
scene()->addItem(new Sprite(pos()));
Evil1 *evilEnemy = qgraphicsitem_cast<Evil1*>(item);
//connect()
if(evilEnemy)
{
connect(this, &Bullet::hitOpponent, evilEnemy, &Evil1::slotTakeDamage);
connect(this, &Bullet::hitOpponent, evilEnemy, &Evil1::slotShowHealth);
}
emit hitOpponent(item);
deleteLater();
}
}
if( x() < 0){
deleteLater();
}
if(x() > scene()->width()){
deleteLater();
}
if( y() < 0){
deleteLater();
}
if( y() > scene()->height())
{
deleteLater();
}
}
Bullet::~Bullet()
{
}
QPainterPath Bullet::shape() const
{
return QPainterPath();
}
| [
"[email protected]"
] | |
c0d4b30c4f8f531edd5875921ad5223cbf53d276 | ed275d7bb2ee5eba732ceb02226b8161584761b5 | /fk/slience/coroutine/coroutine.cpp | efa086313ded2f520f6bba698809fd69b73bbd8e | [] | no_license | wangscript007/server_fk | 55b208139502a115f69657b08ac656b6442d6d3b | 7f4c57710f0d7f4a43018f4518a127358364c9db | refs/heads/master | 2022-01-28T23:25:14.457886 | 2019-05-05T07:23:09 | 2019-05-05T07:23:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,004 | cpp | #include "slience/coroutine/coroutine.hpp"
#include "slience/base/tls.hpp"
#include <cassert>
M_COROUTINE_NAMESPACE_BEGIN
#define gschedule base::tlsdata<_schedule_>::data()
unsigned int Coroutine::curid() {
_schedule_& schedule = gschedule;
if (schedule._curco) {
return schedule._curco->_id;
}
return M_MAIN_COROUTINE_ID;
}
void Coroutine::_alloc_schedule_(_schedule_& schedule) {
if (!schedule._co) {
schedule._nco = 0;
schedule._cap = DEFAULT_COROUTINE;
schedule._curco = NULL;
schedule._co = (_coroutine_**)malloc(sizeof(_coroutine_*) * schedule._cap);
assert(schedule._co);
memset(schedule._co, 0, sizeof(_coroutine_*) * schedule._cap);
schedule._freeid.clear();
}
else {
if (schedule._nco < schedule._cap) {
return;
}
int cap = schedule._cap * 2;
schedule._co = (_coroutine_**)realloc(schedule._co, cap * sizeof(_coroutine_*));
assert(schedule._co);
memset(schedule._co + schedule._cap, 0, cap * sizeof(_coroutine_*));
schedule._cap = cap;
}
}
_coroutine_* Coroutine::_alloc_co_(_schedule_& schedule, _coroutine_func_ routine, void* data) {
_coroutine_* co = (_coroutine_*)malloc(sizeof(_coroutine_));
co->_function = routine;
co->_data = data;
co->_status = COROUTINE_READY;
if (!schedule._freeid.empty()) {
int id = schedule._freeid.back();
schedule._freeid.pop_back();
schedule._co[id - 1] = co;
co->_id = id;
}
else {
if (schedule._nco == schedule._cap) {
_alloc_schedule_(schedule);
}
schedule._co[schedule._nco] = co;
++schedule._nco;
co->_id = schedule._nco;
}
return co;
}
bool Coroutine::_check_co_id(_schedule_& schedule, int co_id) {
if (co_id <= M_MAIN_COROUTINE_ID) {
return false;
}
if (co_id > schedule._cap) {
return false;
}
return true;
}
bool Coroutine::_check_resume_(_schedule_& schedule, int co_id) {
if (schedule._curco) {
return false;
}
return _check_co_id(schedule, co_id);
}
M_COROUTINE_NAMESPACE_END | [
"[email protected]"
] | |
1d9affb64e5a12dfe0d660e1244939b962f39e34 | a92b18defb50c5d1118a11bc364f17b148312028 | /src/prod/src/Store/TSEnumeration.cpp | 6832a14bc94a4629d7e0284d5743b41462760be9 | [
"MIT"
] | permissive | KDSBest/service-fabric | 34694e150fde662286e25f048fb763c97606382e | fe61c45b15a30fb089ad891c68c893b3a976e404 | refs/heads/master | 2023-01-28T23:19:25.040275 | 2020-11-30T11:11:58 | 2020-11-30T11:11:58 | 301,365,601 | 1 | 0 | MIT | 2020-11-30T11:11:59 | 2020-10-05T10:05:53 | null | UTF-8 | C++ | false | false | 4,750 | cpp | // ------------------------------------------------------------
// 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"
using namespace Api;
using namespace Common;
using namespace Data;
using namespace ktl;
using namespace ServiceModel;
using namespace std;
using namespace Store;
StringLiteral const TraceComponent("TSEnumeration");
TSEnumeration::TSEnumeration(
::Store::PartitionedReplicaId const & partitionedReplicaId,
wstring const & type,
wstring const & keyPrefix,
IKvs::SPtr const & innerStore,
IKvsTransaction::SPtr && storeTx,
IKvsEnumerator::SPtr && innerEnum)
: TSEnumerationBase(partitionedReplicaId, type, keyPrefix, false) // strictPrefix check performed in KeyValueStoreEnumeratorBase
, innerStore_(innerStore)
, storeTx_(move(storeTx))
, innerEnum_(move(innerEnum))
, traceId_()
{
traceId_ = wformatString("[{0}+{1}]",
PartitionedReplicaTraceComponent::TraceId,
TextTraceThis);
WriteNoise(
TraceComponent,
"{0} ctor({1}, {2})",
this->TraceId,
this->GetTargetType(),
this->GetTargetKeyPrefix());
}
shared_ptr<TSEnumeration> TSEnumeration::Create(
::Store::PartitionedReplicaId const & partitionedReplicaId,
wstring const & type,
wstring const & keyPrefix,
IKvs::SPtr const & innerStore,
IKvsTransaction::SPtr && storeTx,
IKvsEnumerator::SPtr && enumerator)
{
return shared_ptr<TSEnumeration>(new TSEnumeration(partitionedReplicaId, type, keyPrefix, innerStore, move(storeTx), move(enumerator)));
}
TSEnumeration::~TSEnumeration()
{
WriteNoise(
TraceComponent,
"{0} ~dtor",
this->TraceId);
}
ErrorCode TSEnumeration::MoveNext()
{
return this->OnMoveNextBase();
}
bool TSEnumeration::OnInnerMoveNext()
{
return innerEnum_->MoveNext();
}
KString::SPtr TSEnumeration::OnGetCurrentKey()
{
return innerEnum_->Current();
}
ErrorCode TSEnumeration::CurrentOperationLSN(__inout _int64 & lsn)
{
IKvsGetEntry currentEntry;
auto error = this->InnerGetCurrentEntry(currentEntry);
if (!error.IsSuccess()) { return error; }
lsn = currentEntry.Key;
WriteNoise(
TraceComponent,
"{0} CurrentLsn({1}, {2}) lsn={3}",
this->TraceId,
this->GetCurrentType(),
this->GetCurrentKey(),
lsn);
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentLastModifiedFILETIME(__inout FILETIME & filetime)
{
// TODO: Used by Naming service
//
FILETIME result = {0};
filetime = result;
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentLastModifiedOnPrimaryFILETIME(__inout FILETIME & filetime)
{
// TODO: Used by managed KVS
//
FILETIME result = {0};
filetime = result;
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentType(__inout std::wstring & type)
{
type = this->GetCurrentType();
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentKey(__inout std::wstring & key)
{
key = this->GetCurrentKey();
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentValue(__inout std::vector<byte> & value)
{
value.clear();
IKvsGetEntry currentEntry;
auto error = this->InnerGetCurrentEntry(currentEntry);
if (!error.IsSuccess()) { return error; }
value = this->ToByteVector(currentEntry.Value);
WriteNoise(
TraceComponent,
"{0} CurrentValue({1}, {2}) {3} bytes",
this->TraceId,
this->GetCurrentType(),
this->GetCurrentKey(),
value.size());
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::CurrentValueSize(__inout size_t & size)
{
IKvsGetEntry currentEntry;
auto error = this->InnerGetCurrentEntry(currentEntry);
if (!error.IsSuccess()) { return error; }
size = currentEntry.Value->QuerySize();
return ErrorCodeValue::Success;
}
ErrorCode TSEnumeration::InnerGetCurrentEntry(__out IKvsGetEntry & currentEntry)
{
KString::SPtr currentKey;
TRY_CATCH_VOID( currentKey = innerEnum_->Current() );
bool found = false;
TRY_CATCH_VOID( found = SyncAwait(innerStore_->ConditionalGetAsync(
*storeTx_,
currentKey,
TimeSpan::MaxValue,
currentEntry,
CancellationToken::None)) );
return found ? ErrorCodeValue::Success : ErrorCodeValue::NotFound;
}
StringLiteral const & TSEnumeration::GetTraceComponent() const
{
return TraceComponent;
}
wstring const & TSEnumeration::GetTraceId() const
{
return this->TraceId;
}
| [
"[email protected]"
] | |
f9cba6b90f8541b834b74e5e58f9547fc18b2bc8 | c9e6e57d5b9ee314bf54dcf8b88607e8e6dc68ec | /Iris Engine/WaitForTimer.cpp | 99966de43d13db8284ff2ad2599ce67a305702c3 | [
"Libpng",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause",
"IJG",
"MIT",
"Zlib",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | diegodan1893/Iris-Engine | 81d40757e187dbde81eeb45bf9bf97c1806140e6 | a2c527c7c586eb749f954a0fa10f0e040b4508d5 | refs/heads/master | 2022-11-05T16:39:54.436579 | 2022-04-25T17:19:50 | 2022-04-25T17:19:50 | 143,319,563 | 14 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 242 | cpp | #include "WaitForTimer.h"
#include "GameObjectManager.h"
WaitForTimer::WaitForTimer(GameObjectManager* gameObjectManager)
:gameObjectManager(gameObjectManager)
{
}
bool WaitForTimer::ready()
{
return gameObjectManager->timerFinished();
}
| [
"[email protected]"
] | |
de1c0b373504a71972ec198633061de6e5fbdab1 | c82556c4b54502205761ab33cf31fd27eca1e8ab | /SystemC Model/hardware/fcfsinterconnect.hpp | ae34b3ee8deff386c5eba909e6542853c883a385 | [
"Apache-2.0"
] | permissive | PETAMC/MDPI-Applied-Sciences-2021 | ee248819de53eb56843d0303ba7822813adbdd8e | 25c7de4e1356ff69350409995085d7471d991cbd | refs/heads/main | 2023-04-08T12:46:48.514523 | 2021-05-31T03:42:29 | 2021-05-31T03:42:29 | 369,064,108 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | hpp | #ifndef FCFS_INTERCONNECT_HPP
#define FCFS_INTERCONNECT_HPP
#include <hardware/interconnect.hpp>
class FCFSInterconnect
: public Interconnect
{
public:
FCFSInterconnect(const char* name)
: Interconnect(name) {};
};
#endif
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
| [
"[email protected]"
] | |
08ab025cbbdd8ac610c2d75b931c57401627bf8b | 9b87a301583a802b9734b96fa4824bcd47db0f7e | /libraries/Filter/Filter.h | a66fb3d6262543f6f598e23b6aeb5086e76f8f0c | [] | no_license | alsaibie/RescueBot | 89221276a19e13e62fcf25f4cb8e3a4e3de4725e | 2318bbd0b373a98763bdf7e90e8710f9ad4f540a | refs/heads/master | 2021-01-10T14:23:46.709062 | 2014-11-05T19:39:08 | 2014-11-05T19:39:08 | 54,488,274 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 456 | h | //Low pass butterworth filter order=2 alpha1=0.5
#pragma once
class Filter
{
public:
Filter()
{
for(int i=0; i <= 3; i++)
v[i]=0.0;
}
private:
float v[4];
public:
float step(float x) //class II
{
v[0] = v[1];
v[1] = v[2];
v[2] = v[3];
v[3] = (1.809893300751e-2 * x)
+ ( 0.2780599176 * v[0])
+ ( -1.1828932620 * v[1])
+ ( 1.7600418803 * v[2]);
return
(v[0] + v[3])
+3 * (v[1] + v[2]);
}
}; | [
"[email protected]"
] | |
0ca427f4fefef3cd1eadf41a15ab4b83bc4ffe4f | 97dba80026128e9296e575bb58b9cc7867bbc77f | /others/microsoft/B.cpp | 0e16c063c6ac19327272c09890e77e6254614f3f | [] | no_license | intfloat/AlgoSolutions | 5272be3dfd72485ff78888325a98c25b2623e3cb | 2f7b2f3c4c8a25eb46322e7f8894263ecd286248 | refs/heads/master | 2021-12-23T08:18:32.176193 | 2021-11-01T05:53:27 | 2021-11-01T05:53:27 | 9,474,989 | 18 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,279 | cpp | #include <bits/stdc++.h>
#define FOR(i, n) for (int i = 0; i < (int)n; ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = INT_MAX / 2;
char s[100005];
bool banned[1000];
inline bool check(int a, int b) {
return !banned[a * 26 + b];
}
int main() {
int n, m;
scanf("%d", &n);
memset(banned, false, sizeof banned);
scanf("%s", s);
scanf("%d", &m);
char cc[5];
FOR(i, m) {
scanf("%s", cc);
int a = cc[0] - 'a';
int b = cc[1] - 'a';
banned[a * 26 + b] = true;
banned[b * 26 + a] = true;
}
vector<vector<int> > dp(n, vector<int>(27, INF));
FOR(i, n) dp[i][26] = i + 1;
dp[0][s[0] - 'a'] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 26; ++j) {
int cur = s[i] - 'a';
if (cur != j) dp[i][j] = min(INF, dp[i - 1][j] + 1);
else {
dp[i][j] = min(dp[i - 1][26], dp[i - 1][j] + 1);
for (int k = 0; k < 26; ++k) {
if (!check(k, j)) continue;
dp[i][j] = min(dp[i][j], dp[i - 1][k]);
}
}
}
}
int res = INF;
FOR(i, 27) res = min(res, dp[n - 1][i]);
cout << res << endl;
return 0;
}
| [
"[email protected]"
] | |
16c4895f2e5c0e0ed2785166220ce304a44169be | 721d70011e3b9447113b0f62d5e6bb00c54b7008 | /windows/mingw/i686-w64-mingw32/include/qedit.h | 81a33a01cb23f50dcc6f98270d6a26b31f28f0f2 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] | permissive | mrmoss/parrot_kinect | d8f3dd477dc6206d54f17266fc618e5e5705fde3 | 5e118c7b5a31bfa999cd3eb8777677f923fa80b0 | refs/heads/master | 2021-01-10T21:06:29.716162 | 2015-11-11T22:11:50 | 2015-11-11T22:11:50 | 8,966,232 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,021 | h | /*** Autogenerated by WIDL 1.5.25 from direct-x/include/qedit.idl - Do not edit ***/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __qedit_h__
#define __qedit_h__
/* Forward declarations */
#ifndef __ISampleGrabberCB_FWD_DEFINED__
#define __ISampleGrabberCB_FWD_DEFINED__
typedef interface ISampleGrabberCB ISampleGrabberCB;
#endif
#ifndef __ISampleGrabber_FWD_DEFINED__
#define __ISampleGrabber_FWD_DEFINED__
typedef interface ISampleGrabber ISampleGrabber;
#endif
#ifndef __IMediaDet_FWD_DEFINED__
#define __IMediaDet_FWD_DEFINED__
typedef interface IMediaDet IMediaDet;
#endif
#ifndef __MediaDet_FWD_DEFINED__
#define __MediaDet_FWD_DEFINED__
#ifdef __cplusplus
typedef class MediaDet MediaDet;
#else
typedef struct MediaDet MediaDet;
#endif /* defined __cplusplus */
#endif /* defined __MediaDet_FWD_DEFINED__ */
/* Headers for imported files */
#include <oaidl.h>
#include <ocidl.h>
#include <amstream.h>
#include <msxml.h>
#ifdef __cplusplus
extern "C" {
#endif
/*****************************************************************************
* ISampleGrabberCB interface
*/
#ifndef __ISampleGrabberCB_INTERFACE_DEFINED__
#define __ISampleGrabberCB_INTERFACE_DEFINED__
DEFINE_GUID(IID_ISampleGrabberCB, 0x0579154a, 0x2b53, 0x4994, 0xb0,0xd0, 0xe7,0x73,0x14,0x8e,0xff,0x85);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("0579154a-2b53-4994-b0d0-e773148eff85")
ISampleGrabberCB : public IUnknown
{
virtual HRESULT STDMETHODCALLTYPE SampleCB(
double SampleTime,
IMediaSample *pSample) = 0;
virtual HRESULT STDMETHODCALLTYPE BufferCB(
double SampleTime,
BYTE *pBuffer,
LONG BufferLen) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(ISampleGrabberCB, 0x0579154a, 0x2b53, 0x4994, 0xb0,0xd0, 0xe7,0x73,0x14,0x8e,0xff,0x85)
#endif
#else
typedef struct ISampleGrabberCBVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
ISampleGrabberCB* This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
ISampleGrabberCB* This);
ULONG (STDMETHODCALLTYPE *Release)(
ISampleGrabberCB* This);
/*** ISampleGrabberCB methods ***/
HRESULT (STDMETHODCALLTYPE *SampleCB)(
ISampleGrabberCB* This,
double SampleTime,
IMediaSample *pSample);
HRESULT (STDMETHODCALLTYPE *BufferCB)(
ISampleGrabberCB* This,
double SampleTime,
BYTE *pBuffer,
LONG BufferLen);
END_INTERFACE
} ISampleGrabberCBVtbl;
interface ISampleGrabberCB {
CONST_VTBL ISampleGrabberCBVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define ISampleGrabberCB_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISampleGrabberCB_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISampleGrabberCB_Release(This) (This)->lpVtbl->Release(This)
/*** ISampleGrabberCB methods ***/
#define ISampleGrabberCB_SampleCB(This,SampleTime,pSample) (This)->lpVtbl->SampleCB(This,SampleTime,pSample)
#define ISampleGrabberCB_BufferCB(This,SampleTime,pBuffer,BufferLen) (This)->lpVtbl->BufferCB(This,SampleTime,pBuffer,BufferLen)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT ISampleGrabberCB_QueryInterface(ISampleGrabberCB* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG ISampleGrabberCB_AddRef(ISampleGrabberCB* This) {
return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG ISampleGrabberCB_Release(ISampleGrabberCB* This) {
return This->lpVtbl->Release(This);
}
/*** ISampleGrabberCB methods ***/
static FORCEINLINE HRESULT ISampleGrabberCB_SampleCB(ISampleGrabberCB* This,double SampleTime,IMediaSample *pSample) {
return This->lpVtbl->SampleCB(This,SampleTime,pSample);
}
static FORCEINLINE HRESULT ISampleGrabberCB_BufferCB(ISampleGrabberCB* This,double SampleTime,BYTE *pBuffer,LONG BufferLen) {
return This->lpVtbl->BufferCB(This,SampleTime,pBuffer,BufferLen);
}
#endif
#endif
#endif
HRESULT STDMETHODCALLTYPE ISampleGrabberCB_SampleCB_Proxy(
ISampleGrabberCB* This,
double SampleTime,
IMediaSample *pSample);
void __RPC_STUB ISampleGrabberCB_SampleCB_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabberCB_BufferCB_Proxy(
ISampleGrabberCB* This,
double SampleTime,
BYTE *pBuffer,
LONG BufferLen);
void __RPC_STUB ISampleGrabberCB_BufferCB_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
#endif /* __ISampleGrabberCB_INTERFACE_DEFINED__ */
/*****************************************************************************
* ISampleGrabber interface
*/
#ifndef __ISampleGrabber_INTERFACE_DEFINED__
#define __ISampleGrabber_INTERFACE_DEFINED__
DEFINE_GUID(IID_ISampleGrabber, 0x6b652fff, 0x11fe, 0x4fce, 0x92,0xad, 0x02,0x66,0xb5,0xd7,0xc7,0x8f);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("6b652fff-11fe-4fce-92ad-0266b5d7c78f")
ISampleGrabber : public IUnknown
{
virtual HRESULT STDMETHODCALLTYPE SetOneShot(
WINBOOL OneShot) = 0;
virtual HRESULT STDMETHODCALLTYPE SetMediaType(
const AM_MEDIA_TYPE *pType) = 0;
virtual HRESULT STDMETHODCALLTYPE GetConnectedMediaType(
AM_MEDIA_TYPE *pType) = 0;
virtual HRESULT STDMETHODCALLTYPE SetBufferSamples(
WINBOOL BufferThem) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentBuffer(
LONG *pBufferSize,
LONG *pBuffer) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentSample(
IMediaSample **ppSample) = 0;
virtual HRESULT STDMETHODCALLTYPE SetCallback(
ISampleGrabberCB *pCallback,
LONG WhichMethodToCallback) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(ISampleGrabber, 0x6b652fff, 0x11fe, 0x4fce, 0x92,0xad, 0x02,0x66,0xb5,0xd7,0xc7,0x8f)
#endif
#else
typedef struct ISampleGrabberVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
ISampleGrabber* This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
ISampleGrabber* This);
ULONG (STDMETHODCALLTYPE *Release)(
ISampleGrabber* This);
/*** ISampleGrabber methods ***/
HRESULT (STDMETHODCALLTYPE *SetOneShot)(
ISampleGrabber* This,
WINBOOL OneShot);
HRESULT (STDMETHODCALLTYPE *SetMediaType)(
ISampleGrabber* This,
const AM_MEDIA_TYPE *pType);
HRESULT (STDMETHODCALLTYPE *GetConnectedMediaType)(
ISampleGrabber* This,
AM_MEDIA_TYPE *pType);
HRESULT (STDMETHODCALLTYPE *SetBufferSamples)(
ISampleGrabber* This,
WINBOOL BufferThem);
HRESULT (STDMETHODCALLTYPE *GetCurrentBuffer)(
ISampleGrabber* This,
LONG *pBufferSize,
LONG *pBuffer);
HRESULT (STDMETHODCALLTYPE *GetCurrentSample)(
ISampleGrabber* This,
IMediaSample **ppSample);
HRESULT (STDMETHODCALLTYPE *SetCallback)(
ISampleGrabber* This,
ISampleGrabberCB *pCallback,
LONG WhichMethodToCallback);
END_INTERFACE
} ISampleGrabberVtbl;
interface ISampleGrabber {
CONST_VTBL ISampleGrabberVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define ISampleGrabber_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISampleGrabber_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISampleGrabber_Release(This) (This)->lpVtbl->Release(This)
/*** ISampleGrabber methods ***/
#define ISampleGrabber_SetOneShot(This,OneShot) (This)->lpVtbl->SetOneShot(This,OneShot)
#define ISampleGrabber_SetMediaType(This,pType) (This)->lpVtbl->SetMediaType(This,pType)
#define ISampleGrabber_GetConnectedMediaType(This,pType) (This)->lpVtbl->GetConnectedMediaType(This,pType)
#define ISampleGrabber_SetBufferSamples(This,BufferThem) (This)->lpVtbl->SetBufferSamples(This,BufferThem)
#define ISampleGrabber_GetCurrentBuffer(This,pBufferSize,pBuffer) (This)->lpVtbl->GetCurrentBuffer(This,pBufferSize,pBuffer)
#define ISampleGrabber_GetCurrentSample(This,ppSample) (This)->lpVtbl->GetCurrentSample(This,ppSample)
#define ISampleGrabber_SetCallback(This,pCallback,WhichMethodToCallback) (This)->lpVtbl->SetCallback(This,pCallback,WhichMethodToCallback)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT ISampleGrabber_QueryInterface(ISampleGrabber* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG ISampleGrabber_AddRef(ISampleGrabber* This) {
return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG ISampleGrabber_Release(ISampleGrabber* This) {
return This->lpVtbl->Release(This);
}
/*** ISampleGrabber methods ***/
static FORCEINLINE HRESULT ISampleGrabber_SetOneShot(ISampleGrabber* This,WINBOOL OneShot) {
return This->lpVtbl->SetOneShot(This,OneShot);
}
static FORCEINLINE HRESULT ISampleGrabber_SetMediaType(ISampleGrabber* This,const AM_MEDIA_TYPE *pType) {
return This->lpVtbl->SetMediaType(This,pType);
}
static FORCEINLINE HRESULT ISampleGrabber_GetConnectedMediaType(ISampleGrabber* This,AM_MEDIA_TYPE *pType) {
return This->lpVtbl->GetConnectedMediaType(This,pType);
}
static FORCEINLINE HRESULT ISampleGrabber_SetBufferSamples(ISampleGrabber* This,WINBOOL BufferThem) {
return This->lpVtbl->SetBufferSamples(This,BufferThem);
}
static FORCEINLINE HRESULT ISampleGrabber_GetCurrentBuffer(ISampleGrabber* This,LONG *pBufferSize,LONG *pBuffer) {
return This->lpVtbl->GetCurrentBuffer(This,pBufferSize,pBuffer);
}
static FORCEINLINE HRESULT ISampleGrabber_GetCurrentSample(ISampleGrabber* This,IMediaSample **ppSample) {
return This->lpVtbl->GetCurrentSample(This,ppSample);
}
static FORCEINLINE HRESULT ISampleGrabber_SetCallback(ISampleGrabber* This,ISampleGrabberCB *pCallback,LONG WhichMethodToCallback) {
return This->lpVtbl->SetCallback(This,pCallback,WhichMethodToCallback);
}
#endif
#endif
#endif
HRESULT STDMETHODCALLTYPE ISampleGrabber_SetOneShot_Proxy(
ISampleGrabber* This,
WINBOOL OneShot);
void __RPC_STUB ISampleGrabber_SetOneShot_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_SetMediaType_Proxy(
ISampleGrabber* This,
const AM_MEDIA_TYPE *pType);
void __RPC_STUB ISampleGrabber_SetMediaType_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_GetConnectedMediaType_Proxy(
ISampleGrabber* This,
AM_MEDIA_TYPE *pType);
void __RPC_STUB ISampleGrabber_GetConnectedMediaType_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_SetBufferSamples_Proxy(
ISampleGrabber* This,
WINBOOL BufferThem);
void __RPC_STUB ISampleGrabber_SetBufferSamples_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_GetCurrentBuffer_Proxy(
ISampleGrabber* This,
LONG *pBufferSize,
LONG *pBuffer);
void __RPC_STUB ISampleGrabber_GetCurrentBuffer_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_GetCurrentSample_Proxy(
ISampleGrabber* This,
IMediaSample **ppSample);
void __RPC_STUB ISampleGrabber_GetCurrentSample_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE ISampleGrabber_SetCallback_Proxy(
ISampleGrabber* This,
ISampleGrabberCB *pCallback,
LONG WhichMethodToCallback);
void __RPC_STUB ISampleGrabber_SetCallback_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
#endif /* __ISampleGrabber_INTERFACE_DEFINED__ */
/*****************************************************************************
* IMediaDet interface
*/
#ifndef __IMediaDet_INTERFACE_DEFINED__
#define __IMediaDet_INTERFACE_DEFINED__
DEFINE_GUID(IID_IMediaDet, 0x65bd0710, 0x24d2, 0x4ff7, 0x93,0x24, 0xed,0x2e,0x5d,0x3a,0xba,0xfa);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("65bd0710-24d2-4ff7-9324-ed2e5d3abafa")
IMediaDet : public IUnknown
{
virtual HRESULT STDMETHODCALLTYPE get_Filter(
IUnknown **pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE put_Filter(
IUnknown *newVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_OutputStreams(
LONG *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_CurrentStream(
LONG *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE put_CurrentStream(
LONG newVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_StreamType(
GUID *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_StreamTypeB(
BSTR *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_StreamLength(
double *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Filename(
BSTR *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE put_Filename(
BSTR newVal) = 0;
virtual HRESULT STDMETHODCALLTYPE GetBitmapBits(
double StreamTime,
LONG *pBufferSize,
char *pBuffer,
LONG Width,
LONG Height) = 0;
virtual HRESULT STDMETHODCALLTYPE WriteBitmapBits(
double StreamTime,
LONG Width,
LONG Height,
BSTR Filename) = 0;
virtual HRESULT STDMETHODCALLTYPE get_StreamMediaType(
AM_MEDIA_TYPE *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE GetSampleGrabber(
ISampleGrabber **ppVal) = 0;
virtual HRESULT STDMETHODCALLTYPE get_FrameRate(
double *pVal) = 0;
virtual HRESULT STDMETHODCALLTYPE EnterBitmapGrabMode(
double SeekTime) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMediaDet, 0x65bd0710, 0x24d2, 0x4ff7, 0x93,0x24, 0xed,0x2e,0x5d,0x3a,0xba,0xfa)
#endif
#else
typedef struct IMediaDetVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
IMediaDet* This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
IMediaDet* This);
ULONG (STDMETHODCALLTYPE *Release)(
IMediaDet* This);
/*** IMediaDet methods ***/
HRESULT (STDMETHODCALLTYPE *get_Filter)(
IMediaDet* This,
IUnknown **pVal);
HRESULT (STDMETHODCALLTYPE *put_Filter)(
IMediaDet* This,
IUnknown *newVal);
HRESULT (STDMETHODCALLTYPE *get_OutputStreams)(
IMediaDet* This,
LONG *pVal);
HRESULT (STDMETHODCALLTYPE *get_CurrentStream)(
IMediaDet* This,
LONG *pVal);
HRESULT (STDMETHODCALLTYPE *put_CurrentStream)(
IMediaDet* This,
LONG newVal);
HRESULT (STDMETHODCALLTYPE *get_StreamType)(
IMediaDet* This,
GUID *pVal);
HRESULT (STDMETHODCALLTYPE *get_StreamTypeB)(
IMediaDet* This,
BSTR *pVal);
HRESULT (STDMETHODCALLTYPE *get_StreamLength)(
IMediaDet* This,
double *pVal);
HRESULT (STDMETHODCALLTYPE *get_Filename)(
IMediaDet* This,
BSTR *pVal);
HRESULT (STDMETHODCALLTYPE *put_Filename)(
IMediaDet* This,
BSTR newVal);
HRESULT (STDMETHODCALLTYPE *GetBitmapBits)(
IMediaDet* This,
double StreamTime,
LONG *pBufferSize,
char *pBuffer,
LONG Width,
LONG Height);
HRESULT (STDMETHODCALLTYPE *WriteBitmapBits)(
IMediaDet* This,
double StreamTime,
LONG Width,
LONG Height,
BSTR Filename);
HRESULT (STDMETHODCALLTYPE *get_StreamMediaType)(
IMediaDet* This,
AM_MEDIA_TYPE *pVal);
HRESULT (STDMETHODCALLTYPE *GetSampleGrabber)(
IMediaDet* This,
ISampleGrabber **ppVal);
HRESULT (STDMETHODCALLTYPE *get_FrameRate)(
IMediaDet* This,
double *pVal);
HRESULT (STDMETHODCALLTYPE *EnterBitmapGrabMode)(
IMediaDet* This,
double SeekTime);
END_INTERFACE
} IMediaDetVtbl;
interface IMediaDet {
CONST_VTBL IMediaDetVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMediaDet_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMediaDet_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMediaDet_Release(This) (This)->lpVtbl->Release(This)
/*** IMediaDet methods ***/
#define IMediaDet_get_Filter(This,pVal) (This)->lpVtbl->get_Filter(This,pVal)
#define IMediaDet_put_Filter(This,newVal) (This)->lpVtbl->put_Filter(This,newVal)
#define IMediaDet_get_OutputStreams(This,pVal) (This)->lpVtbl->get_OutputStreams(This,pVal)
#define IMediaDet_get_CurrentStream(This,pVal) (This)->lpVtbl->get_CurrentStream(This,pVal)
#define IMediaDet_put_CurrentStream(This,newVal) (This)->lpVtbl->put_CurrentStream(This,newVal)
#define IMediaDet_get_StreamType(This,pVal) (This)->lpVtbl->get_StreamType(This,pVal)
#define IMediaDet_get_StreamTypeB(This,pVal) (This)->lpVtbl->get_StreamTypeB(This,pVal)
#define IMediaDet_get_StreamLength(This,pVal) (This)->lpVtbl->get_StreamLength(This,pVal)
#define IMediaDet_get_Filename(This,pVal) (This)->lpVtbl->get_Filename(This,pVal)
#define IMediaDet_put_Filename(This,newVal) (This)->lpVtbl->put_Filename(This,newVal)
#define IMediaDet_GetBitmapBits(This,StreamTime,pBufferSize,pBuffer,Width,Height) (This)->lpVtbl->GetBitmapBits(This,StreamTime,pBufferSize,pBuffer,Width,Height)
#define IMediaDet_WriteBitmapBits(This,StreamTime,Width,Height,Filename) (This)->lpVtbl->WriteBitmapBits(This,StreamTime,Width,Height,Filename)
#define IMediaDet_get_StreamMediaType(This,pVal) (This)->lpVtbl->get_StreamMediaType(This,pVal)
#define IMediaDet_GetSampleGrabber(This,ppVal) (This)->lpVtbl->GetSampleGrabber(This,ppVal)
#define IMediaDet_get_FrameRate(This,pVal) (This)->lpVtbl->get_FrameRate(This,pVal)
#define IMediaDet_EnterBitmapGrabMode(This,SeekTime) (This)->lpVtbl->EnterBitmapGrabMode(This,SeekTime)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMediaDet_QueryInterface(IMediaDet* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMediaDet_AddRef(IMediaDet* This) {
return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMediaDet_Release(IMediaDet* This) {
return This->lpVtbl->Release(This);
}
/*** IMediaDet methods ***/
static FORCEINLINE HRESULT IMediaDet_get_Filter(IMediaDet* This,IUnknown **pVal) {
return This->lpVtbl->get_Filter(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_put_Filter(IMediaDet* This,IUnknown *newVal) {
return This->lpVtbl->put_Filter(This,newVal);
}
static FORCEINLINE HRESULT IMediaDet_get_OutputStreams(IMediaDet* This,LONG *pVal) {
return This->lpVtbl->get_OutputStreams(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_get_CurrentStream(IMediaDet* This,LONG *pVal) {
return This->lpVtbl->get_CurrentStream(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_put_CurrentStream(IMediaDet* This,LONG newVal) {
return This->lpVtbl->put_CurrentStream(This,newVal);
}
static FORCEINLINE HRESULT IMediaDet_get_StreamType(IMediaDet* This,GUID *pVal) {
return This->lpVtbl->get_StreamType(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_get_StreamTypeB(IMediaDet* This,BSTR *pVal) {
return This->lpVtbl->get_StreamTypeB(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_get_StreamLength(IMediaDet* This,double *pVal) {
return This->lpVtbl->get_StreamLength(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_get_Filename(IMediaDet* This,BSTR *pVal) {
return This->lpVtbl->get_Filename(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_put_Filename(IMediaDet* This,BSTR newVal) {
return This->lpVtbl->put_Filename(This,newVal);
}
static FORCEINLINE HRESULT IMediaDet_GetBitmapBits(IMediaDet* This,double StreamTime,LONG *pBufferSize,char *pBuffer,LONG Width,LONG Height) {
return This->lpVtbl->GetBitmapBits(This,StreamTime,pBufferSize,pBuffer,Width,Height);
}
static FORCEINLINE HRESULT IMediaDet_WriteBitmapBits(IMediaDet* This,double StreamTime,LONG Width,LONG Height,BSTR Filename) {
return This->lpVtbl->WriteBitmapBits(This,StreamTime,Width,Height,Filename);
}
static FORCEINLINE HRESULT IMediaDet_get_StreamMediaType(IMediaDet* This,AM_MEDIA_TYPE *pVal) {
return This->lpVtbl->get_StreamMediaType(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_GetSampleGrabber(IMediaDet* This,ISampleGrabber **ppVal) {
return This->lpVtbl->GetSampleGrabber(This,ppVal);
}
static FORCEINLINE HRESULT IMediaDet_get_FrameRate(IMediaDet* This,double *pVal) {
return This->lpVtbl->get_FrameRate(This,pVal);
}
static FORCEINLINE HRESULT IMediaDet_EnterBitmapGrabMode(IMediaDet* This,double SeekTime) {
return This->lpVtbl->EnterBitmapGrabMode(This,SeekTime);
}
#endif
#endif
#endif
HRESULT STDMETHODCALLTYPE IMediaDet_get_Filter_Proxy(
IMediaDet* This,
IUnknown **pVal);
void __RPC_STUB IMediaDet_get_Filter_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_put_Filter_Proxy(
IMediaDet* This,
IUnknown *newVal);
void __RPC_STUB IMediaDet_put_Filter_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_OutputStreams_Proxy(
IMediaDet* This,
LONG *pVal);
void __RPC_STUB IMediaDet_get_OutputStreams_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_CurrentStream_Proxy(
IMediaDet* This,
LONG *pVal);
void __RPC_STUB IMediaDet_get_CurrentStream_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_put_CurrentStream_Proxy(
IMediaDet* This,
LONG newVal);
void __RPC_STUB IMediaDet_put_CurrentStream_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_StreamType_Proxy(
IMediaDet* This,
GUID *pVal);
void __RPC_STUB IMediaDet_get_StreamType_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_StreamTypeB_Proxy(
IMediaDet* This,
BSTR *pVal);
void __RPC_STUB IMediaDet_get_StreamTypeB_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_StreamLength_Proxy(
IMediaDet* This,
double *pVal);
void __RPC_STUB IMediaDet_get_StreamLength_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_Filename_Proxy(
IMediaDet* This,
BSTR *pVal);
void __RPC_STUB IMediaDet_get_Filename_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_put_Filename_Proxy(
IMediaDet* This,
BSTR newVal);
void __RPC_STUB IMediaDet_put_Filename_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_GetBitmapBits_Proxy(
IMediaDet* This,
double StreamTime,
LONG *pBufferSize,
char *pBuffer,
LONG Width,
LONG Height);
void __RPC_STUB IMediaDet_GetBitmapBits_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_WriteBitmapBits_Proxy(
IMediaDet* This,
double StreamTime,
LONG Width,
LONG Height,
BSTR Filename);
void __RPC_STUB IMediaDet_WriteBitmapBits_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_StreamMediaType_Proxy(
IMediaDet* This,
AM_MEDIA_TYPE *pVal);
void __RPC_STUB IMediaDet_get_StreamMediaType_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_GetSampleGrabber_Proxy(
IMediaDet* This,
ISampleGrabber **ppVal);
void __RPC_STUB IMediaDet_GetSampleGrabber_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_get_FrameRate_Proxy(
IMediaDet* This,
double *pVal);
void __RPC_STUB IMediaDet_get_FrameRate_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMediaDet_EnterBitmapGrabMode_Proxy(
IMediaDet* This,
double SeekTime);
void __RPC_STUB IMediaDet_EnterBitmapGrabMode_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
#endif /* __IMediaDet_INTERFACE_DEFINED__ */
/*****************************************************************************
* MediaDet coclass
*/
DEFINE_GUID(CLSID_MediaDet, 0x65bd0711, 0x24d2, 0x4ff7, 0x93,0x24, 0xed,0x2e,0x5d,0x3a,0xba,0xfa);
#ifdef __cplusplus
class DECLSPEC_UUID("65bd0711-24d2-4ff7-9324-ed2e5d3abafa") MediaDet;
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(MediaDet, 0x65bd0711, 0x24d2, 0x4ff7, 0x93,0x24, 0xed,0x2e,0x5d,0x3a,0xba,0xfa)
#endif
#endif
enum {
E_NOTINTREE = 0x80040400,
E_RENDER_ENGINE_IS_BROKEN = 0x80040401,
E_MUST_INIT_RENDERER = 0x80040402,
E_NOTDETERMINED = 0x80040403,
E_NO_TIMELINE = 0x80040404,
S_WARN_OUTPUTRESET = 40404
};
/* Begin additional prototypes for all interfaces */
ULONG __RPC_USER BSTR_UserSize (ULONG *, ULONG, BSTR *);
unsigned char * __RPC_USER BSTR_UserMarshal (ULONG *, unsigned char *, BSTR *);
unsigned char * __RPC_USER BSTR_UserUnmarshal(ULONG *, unsigned char *, BSTR *);
void __RPC_USER BSTR_UserFree (ULONG *, BSTR *);
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __qedit_h__ */
| [
"[email protected]"
] | |
251409539ac65353a084000fcb0e8f286da85348 | f0c72e77df916351858bffc6f6ace65cc3c7ec8e | /Libraries/LibWeb/DOM/Timer.cpp | a9bf2dcd4bd63b91fb604df76f8c9fd0a8b2001a | [
"BSD-2-Clause"
] | permissive | JacksiroKe/serenity | 9d9ae9aa241cc2de6c66b126e7a7a51b72271b5f | 0bcdb422a4f3c0f999933827557555feb1b25ae4 | refs/heads/master | 2022-12-28T10:23:59.642534 | 2020-10-18T00:23:12 | 2020-10-18T00:23:12 | 294,908,903 | 1 | 0 | BSD-2-Clause | 2020-10-18T00:23:13 | 2020-09-12T09:08:32 | null | UTF-8 | C++ | false | false | 2,323 | cpp | /*
* Copyright (c) 2020, Andreas Kling <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <LibCore/Timer.h>
#include <LibJS/Runtime/Function.h>
#include <LibWeb/DOM/Timer.h>
#include <LibWeb/DOM/Window.h>
namespace Web::DOM {
NonnullRefPtr<Timer> Timer::create_interval(Window& window, int milliseconds, JS::Function& callback)
{
return adopt(*new Timer(window, Type::Interval, milliseconds, callback));
}
NonnullRefPtr<Timer> Timer::create_timeout(Window& window, int milliseconds, JS::Function& callback)
{
return adopt(*new Timer(window, Type::Timeout, milliseconds, callback));
}
Timer::Timer(Window& window, Type type, int milliseconds, JS::Function& callback)
: m_window(window)
, m_type(type)
, m_callback(JS::make_handle(&callback))
{
m_id = window.allocate_timer_id({});
m_timer = Core::Timer::construct(milliseconds, [this] { m_window.timer_did_fire({}, *this); });
if (m_type == Type::Timeout)
m_timer->set_single_shot(true);
}
Timer::~Timer()
{
}
}
| [
"[email protected]"
] | |
aa95e0b77f3cd5b6c8ffdb6913eeacc70679788e | 083100943aa21e05d2eb0ad745349331dd35239a | /aws-cpp-sdk-kms/source/model/KeyListEntry.cpp | 39066bdbb3795758ff0e550bb34b100b14569c96 | [
"JSON",
"MIT",
"Apache-2.0"
] | permissive | bmildner/aws-sdk-cpp | d853faf39ab001b2878de57aa7ba132579d1dcd2 | 983be395fdff4ec944b3bcfcd6ead6b4510b2991 | refs/heads/master | 2021-01-15T16:52:31.496867 | 2015-09-10T06:57:18 | 2015-09-10T06:57:18 | 41,954,994 | 1 | 0 | null | 2015-09-05T08:57:22 | 2015-09-05T08:57:22 | null | UTF-8 | C++ | false | false | 1,599 | cpp | /*
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. 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.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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 <aws/kms/model/KeyListEntry.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::KMS::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
KeyListEntry::KeyListEntry() :
m_keyIdHasBeenSet(false),
m_keyArnHasBeenSet(false)
{
}
KeyListEntry::KeyListEntry(const JsonValue& jsonValue) :
m_keyIdHasBeenSet(false),
m_keyArnHasBeenSet(false)
{
*this = jsonValue;
}
KeyListEntry& KeyListEntry::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("KeyId"))
{
m_keyId = jsonValue.GetString("KeyId");
m_keyIdHasBeenSet = true;
}
if(jsonValue.ValueExists("KeyArn"))
{
m_keyArn = jsonValue.GetString("KeyArn");
m_keyArnHasBeenSet = true;
}
return *this;
}
JsonValue KeyListEntry::Jsonize() const
{
JsonValue payload;
if(m_keyIdHasBeenSet)
{
payload.WithString("KeyId", m_keyId);
}
if(m_keyArnHasBeenSet)
{
payload.WithString("KeyArn", m_keyArn);
}
return std::move(payload);
} | [
"[email protected]"
] | |
80287e1df82bfa3ba6816b51f649c02d8b58f1ef | 5583fb41ebc6e4ca1e3adf5bac5ceb94ba7b663e | /Operator logika.cpp | 8aa53572b96ef9d4876d89c6ce4dc296812c77e9 | [] | no_license | TRISMAN18/Latihan_operator_logika | fc9fd678f220036bd0a0c0243aea722e4f8ad085 | 0a3880fa0227a9c787d3c423b43663520addc915 | refs/heads/master | 2020-07-28T21:13:59.058450 | 2019-09-19T11:49:55 | 2019-09-19T11:49:55 | 209,539,486 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,276 | cpp | #include <iostream>
using namespace std;
int main(){
cout<<"A OR B"<<endl;
cout<<"0 OR 0 ="<<(0 || 0)<<endl;
cout<<"0 OR 0 ="<<(0 || 0)<<endl;
cout<<"0 OR 1 ="<<(0 || 1)<<endl;
cout<<"0 OR 1 ="<<(0 || 1)<<endl;
cout<<"1 OR 0 ="<<(1 || 0)<<endl;
cout<<"1 OR 0 ="<<(1 || 0)<<endl;
cout<<"1 OR 1 ="<<(1 || 1)<<endl;
cout<<"1 OR 1 ="<<(1 || 1)<<endl<<endl;
cout<<"A OR C "<<endl;
cout<<"0 OR 0 ="<<(0 || 0)<<endl;
cout<<"0 OR 1 ="<<(0 || 1)<<endl;
cout<<"0 OR 0 ="<<(0 || 0)<<endl;
cout<<"0 OR 1 ="<<(0 || 1)<<endl;
cout<<"1 OR 0 ="<<(1 || 0)<<endl;
cout<<"1 OR 1 ="<<(1 || 1)<<endl;
cout<<"1 OR 0 ="<<(1 || 0)<<endl;
cout<<"0 OR 0 ="<<(1 || 1)<<endl<<endl;
cout<<"FI =(A OR B)AND(A OR C)"<<endl;
cout<<"0 OR 0 AND 0 OR 0 ="<< ( (0 || 0) && (0 || 0) )<<endl;
cout<<"0 OR 0 AND 0 OR 1 ="<< ( (0 || 0) && (0 || 1) )<<endl;
cout<<"0 OR 1 AND 0 OR 0 ="<< ( (0 || 1) && (0 || 0) )<<endl;
cout<<"0 OR 1 AND 0 OR 1 ="<< ( (0 || 1) && (0 || 1) )<<endl;
cout<<"1 OR 0 AND 1 OR 0 ="<< ( (1 || 0) && (1 || 0) )<<endl;
cout<<"1 OR 0 AND 1 OR 1 ="<< ( (1 || 1) && (1 || 1) )<<endl;
cout<<"1 OR 1 AND 1 OR 0 ="<< ( (1 || 1) && (1 || 0) )<<endl;
cout<<"1 OR 1 AND 1 OR 1 ="<< ( (1 || 1) && (1 || 1) )<<endl<<endl;
return 0;
}
| [
"[email protected]"
] | |
3fb7309bfed7e838e203604c056a93a179900332 | 8e3a873596b1aa0e10ef109e78b2970ce9ba1aae | /week7/smart_obj/smart_ptr/object.h | af64ddb919f0481eb95ede97105309491137bad0 | [] | no_license | HelloJinoo/Object_Oriented | 7657c26c209217f5195878effbe6c1ea0c0a52d8 | 71218bb928ff704eabdeee54a59f4dbf8bccb9c5 | refs/heads/master | 2020-07-24T02:39:02.528038 | 2019-12-16T11:31:21 | 2019-12-16T11:31:21 | 207,776,718 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 368 | h |
#ifndef SMART_PTR_OBJECT_H
#define SMART_PTR_OBJECT_H
#include <iostream>
class Object{
private :
int val;
public :
Object();
explicit Object(int _val);
~Object();
int get() const;
Object operator+(const Object &obj);
Object operator-(const Object &obj);
Object operator*(const Object &obj);
Object operator/(const Object &obj);
};
#endif
| [
"[email protected]"
] | |
a3adef9c87001e6ab4f68385a85dda50cc168e74 | f0f7fbce15f0b9e116cf97a3542f436d8be93b8d | /graphlearn/common/base/time_stamp.cc | 9dfd200b421342a522b2df2514b75413e5a1e3c9 | [
"Apache-2.0"
] | permissive | lorinlee/graph-learn | 2accd9bb4bd06b22778d1f42774c210aacc9681c | 1827c28c570c355e513f24b6a61a88457cfecdaf | refs/heads/master | 2022-12-15T12:43:26.914824 | 2020-09-15T10:39:16 | 2020-09-15T10:42:50 | 295,692,911 | 0 | 0 | Apache-2.0 | 2020-09-15T10:30:01 | 2020-09-15T10:30:01 | null | UTF-8 | C++ | false | false | 1,061 | cc | /* Copyright 2020 Alibaba Group Holding Limited. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "graphlearn/common/base/time_stamp.h"
#include <sys/time.h>
namespace graphlearn {
int64_t GetTimeStampInMs() {
int64_t time = static_cast<int64_t>(GetTimeStampInUs() * 0.001 + 0.01);
return time;
}
int64_t GetTimeStampInUs() {
struct timeval tv;
::gettimeofday(&tv, 0);
int64_t time = tv.tv_sec * 1000000 + tv.tv_usec;
return time;
}
} // namespace graphlearn
| [
"[email protected]"
] | |
4b8d7c0c7020ae665b612b55f443fc57bfa7c3b7 | 63539d1fba8f4f8a4c64dcc5f3ecdc3e2c31b834 | /scripts/links/src/DynamicalVariables.cpp | e18f8cfb62ece349b5f5eb4f99313f4bf213a8a6 | [] | no_license | LipeiDu/cpu-vhb | dd022a3ff73fd81b94f8aa98a41d2b56d16ab533 | aa57de31158ab998d0b6a94fbed01e25f779b5f5 | refs/heads/master | 2021-06-03T07:33:39.359822 | 2018-10-17T16:57:20 | 2018-10-17T16:57:20 | 111,721,017 | 0 | 0 | null | 2018-10-17T16:57:22 | 2017-11-22T18:50:23 | Mathematica | UTF-8 | C++ | false | false | 135 | cpp | /home/derek/MEGA/hydro-resources/cpu-vh-with-fo/scripts/../rhic/rhic-trunk/src/main/cpp/edu/osu/rhic/trunk/hydro/DynamicalVariables.cpp | [
"[email protected]"
] | |
4ddd8964597de4f2265a529c063ca25d0045d2d2 | 12043db0f57f5d9402a99507648bcbb4d9417452 | /Programming_Abstractions/Chapter_04/Exercise_05/Exercise_05/is_magic.cpp | d13b26284896e3d09ee58a6876949c2bd9628a5e | [] | no_license | daniellozuz/CPP | a8afb1ae3353bd483cf953fac8a70b0b1446023c | fdc8957158522fc27aa55a44b3e45333157b843f | refs/heads/master | 2021-05-12T08:31:17.581023 | 2018-03-07T23:41:45 | 2018-03-07T23:41:45 | 117,283,294 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,571 | cpp | #include <iostream>
#include <vector>
using namespace std;
bool is_magic_square(vector<vector<int>> &square);
int sum_line(vector<vector<int>> &square, int row, int col, int d_row, int d_col);
int main(void) {
vector<vector<int>> magic_square1 = {
{ 8, 1, 6 },
{ 3, 5, 7 },
{ 4, 9, 2 },
};
vector<vector<int>> magic_square2 = {
{ 16, 3, 2, 13 },
{ 5, 10, 11, 8 },
{ 9, 6, 7, 12 },
{ 4, 15, 14, 1 },
};
vector<vector<int>> not_a_magic_square1 = {
{ 1, 2 },
{ 3, 4 },
};
vector<vector<int>> not_a_magic_square2 = {
{ 1, 2 },
{ 3, 4 },
{ 5, 6 },
};
cout << is_magic_square(magic_square1) << endl;
cout << is_magic_square(magic_square2) << endl;
cout << is_magic_square(not_a_magic_square1) << endl;
cout << is_magic_square(not_a_magic_square2) << endl;
cin.get();
return 0;
}
bool is_magic_square(vector<vector<int>> &square) {
int value;
if (square.size() != square[0].size())
return false;
value = sum_line(square, 0, 0, 1, 1);
for (int i = 0; i < square.size(); i++) {
if (sum_line(square, 0, i, 1, 0) != value || sum_line(square, i, 0, 0, 1) != value)
return false;
}
return sum_line(square, 0, square.size() - 1, 1, -1) == value;
}
int sum_line(vector<vector<int>> &square, int row, int col, int d_row, int d_col) {
int value = 0;
for (int i = 0; i < square.size(); i++)
value += square[row + i * d_row][col + i * d_col];
return value;
}
| [
"[email protected]"
] | |
d0411e57bbf510ceff88cb207ebb6974479b490e | d876dd989107ab970f91023a3c8ccc6fb230121d | /google/cloud/bigtable/internal/common_client.cc | 898d1e7ade19c539943b9a1799b392005cffb930 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | corn2/google-cloud-cpp | f8af319c720219919135610336399de6f99c4216 | 054efad30977e2ca90e735f7aceb052a70f17662 | refs/heads/master | 2022-09-13T13:51:19.178844 | 2020-05-27T20:59:37 | 2020-05-27T20:59:37 | 267,444,529 | 3 | 0 | Apache-2.0 | 2020-05-27T23:08:45 | 2020-05-27T23:08:44 | null | UTF-8 | C++ | false | false | 1,522 | cc | // Copyright 2018 Google 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
#include "google/cloud/bigtable/internal/common_client.h"
namespace google {
namespace cloud {
namespace bigtable {
inline namespace BIGTABLE_CLIENT_NS {
namespace internal {
std::vector<std::shared_ptr<grpc::Channel>> CreateChannelPool(
std::string const& endpoint, bigtable::ClientOptions const& options) {
std::vector<std::shared_ptr<grpc::Channel>> result;
for (std::size_t i = 0; i != options.connection_pool_size(); ++i) {
auto args = options.channel_arguments();
if (!options.connection_pool_name().empty()) {
args.SetString("cbt-c++/connection-pool-name",
options.connection_pool_name());
}
args.SetInt("cbt-c++/connection-pool-id", static_cast<int>(i));
result.push_back(
grpc::CreateCustomChannel(endpoint, options.credentials(), args));
}
return result;
}
} // namespace internal
} // namespace BIGTABLE_CLIENT_NS
} // namespace bigtable
} // namespace cloud
} // namespace google
| [
"[email protected]"
] | |
393ab3e36e19b5dc28d3a0d85651676c1ebfee3e | 483194ec10e6149c3245ff48c1857f48deba1578 | /External/asio/ip/detail/endpoint.hpp | eaefc2a73e2b289baf5f0ce52ef8fbea679ac244 | [] | no_license | davidroze/StormWebrtc | 3efc68c9e16b34da0728716f460f44ca8a50f59d | cd471d5107c3bfe0cb885caf81063915ad4d386a | refs/heads/master | 2021-05-08T16:43:43.539787 | 2018-02-04T10:05:43 | 2018-02-04T10:05:43 | 120,167,513 | 0 | 0 | null | 2018-02-04T08:24:11 | 2018-02-04T08:24:11 | null | UTF-8 | C++ | false | false | 3,792 | hpp | //
// ip/detail/endpoint.hpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2015 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)
//
#ifndef ASIO_IP_DETAIL_ENDPOINT_HPP
#define ASIO_IP_DETAIL_ENDPOINT_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include <string>
#include "asio/detail/socket_types.hpp"
#include "asio/detail/winsock_init.hpp"
#include "asio/error_code.hpp"
#include "asio/ip/address.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
namespace ip {
namespace detail {
// Helper class for implementating an IP endpoint.
class endpoint
{
public:
// Default constructor.
ASIO_DECL endpoint();
// Construct an endpoint using a family and port number.
ASIO_DECL endpoint(int family, unsigned short port_num);
// Construct an endpoint using an address and port number.
ASIO_DECL endpoint(const asio::ip::address& addr,
unsigned short port_num);
// Copy constructor.
endpoint(const endpoint& other)
: data_(other.data_)
{
}
// Assign from another endpoint.
endpoint& operator=(const endpoint& other)
{
data_ = other.data_;
return *this;
}
// Get the underlying endpoint in the native type.
asio::detail::socket_addr_type* data()
{
return &data_.base;
}
// Get the underlying endpoint in the native type.
const asio::detail::socket_addr_type* data() const
{
return &data_.base;
}
// Get the underlying size of the endpoint in the native type.
std::size_t size() const
{
if (is_v4())
return sizeof(asio::detail::sockaddr_in4_type);
else
return sizeof(asio::detail::sockaddr_in6_type);
}
// Set the underlying size of the endpoint in the native type.
ASIO_DECL void resize(std::size_t new_size);
// Get the capacity of the endpoint in the native type.
std::size_t capacity() const
{
return sizeof(data_);
}
// Get the port associated with the endpoint.
ASIO_DECL unsigned short port() const;
// Set the port associated with the endpoint.
ASIO_DECL void port(unsigned short port_num);
// Get the IP address associated with the endpoint.
ASIO_DECL asio::ip::address address() const;
// Set the IP address associated with the endpoint.
ASIO_DECL void address(const asio::ip::address& addr);
// Compare two endpoints for equality.
ASIO_DECL friend bool operator==(
const endpoint& e1, const endpoint& e2);
// Compare endpoints for ordering.
ASIO_DECL friend bool operator<(
const endpoint& e1, const endpoint& e2);
// Determine whether the endpoint is IPv4.
bool is_v4() const
{
return data_.base.sa_family == ASIO_OS_DEF(AF_INET);
}
// Determine whether the endpoint is IPv6.
bool is_v6() const
{
return data_.base.sa_family == ASIO_OS_DEF(AF_INET6);
}
#if !defined(ASIO_NO_IOSTREAM)
// Convert to a string.
ASIO_DECL std::string to_string(asio::error_code& ec) const;
#endif // !defined(ASIO_NO_IOSTREAM)
private:
// The underlying IP socket address.
union data_union
{
asio::detail::socket_addr_type base;
asio::detail::sockaddr_in4_type v4;
asio::detail::sockaddr_in6_type v6;
} data_;
};
} // namespace detail
} // namespace ip
} // namespace asio
#include "asio/detail/pop_options.hpp"
#if defined(ASIO_HEADER_ONLY)
# include "asio/ip/detail/impl/endpoint.ipp"
#endif // defined(ASIO_HEADER_ONLY)
#endif // ASIO_IP_DETAIL_ENDPOINT_HPP
| [
"[email protected]"
] | |
613f6e18f1e8feb77b1ae93b52a309095a7020ad | fa2cec4d65c07cccbf7dfae3f39b66db76437f06 | /Examples/CAN_Test/samc21_can.h | f0a5514af532f447ed5f9516d33255b27411c33d | [] | no_license | niladridmgit/xplainedniladri | fc286657acbb8d876a322169a88c7bda07991bce | 99d59fb77f675bb30577fdce72e5f069fecedd85 | refs/heads/master | 2023-03-25T21:17:29.777356 | 2021-03-11T18:19:34 | 2021-03-11T18:19:34 | 345,077,138 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,513 | h | /**
* @file
* @author Scott Price <[email protected]>
* @copyright © 2017 Hunt Utilities Group, LLC
* @brief The include file for using the SAMC
* @details
*/
#ifndef _SAMC_CAN_H_
#define _SAMC_CAN_H_
#include "sam.h"
#include "mcan.h"
#include "mcan_helper.h"
#include "mcp_can_dfs.h"
#define MAX_CHAR_IN_MESSAGE CAN_MAX_CHAR_IN_MESSAGE
#include <inttypes.h>
#include <string.h>
/* size of our custom Rx and Tx Buffer Elements, in words */
#define RAM_BUF_SIZE (MCAN_RAM_BUF_HDR_SIZE + 64u / 4)
#define RAM_ARRAY_SIZE_FILT_STD (8u)
#define RAM_ARRAY_SIZE_FILT_EXT (8u)
#define RAM_FIFO_SIZE_RX0 (12u)
/* no Rx FIFO 1 in our Message RAM */
#define RAM_ARRAY_SIZE_RX (4u)
/* no Tx Event FIFO in our Message RAM */
#define RAM_ARRAY_SIZE_TX (0u)
#define RAM_FIFO_SIZE_TX (4u)
/* size of our custom Message RAM, in words */
#define MSG_RAM_SIZE ( \
RAM_ARRAY_SIZE_FILT_STD * MCAN_RAM_FILT_STD_SIZE \
+ RAM_ARRAY_SIZE_FILT_EXT * MCAN_RAM_FILT_EXT_SIZE \
+ RAM_FIFO_SIZE_RX0 * RAM_BUF_SIZE \
+ RAM_ARRAY_SIZE_RX * RAM_BUF_SIZE \
+ RAM_ARRAY_SIZE_TX * RAM_BUF_SIZE \
+ RAM_FIFO_SIZE_TX * RAM_BUF_SIZE )
#define MSG_LEN_1_CAN 8
#define MSG_LEN_1_CAN_FD 64
#define MSG_LEN_2_CAN 7
#define MSG_LEN_2_CAN_FD 48
#define MSG_ID_ALLOW_ALL_MASK 0x000ul /* bits 0 & 1 are don't care */
#define RX_BUFFER_0 0
#define RX_BUFFER_1 1
#define FILTER_0 0
#define FILTER_1 1
struct frame_desc {
uint32_t id;
uint8_t data[64];
uint8_t len;
uint8_t buf_idx;
};
typedef struct {
uint32_t id;
uint8_t len;
uint8_t ext;
uint8_t buffer[MAX_CHAR_IN_MESSAGE];
uint8_t ret;
} mcp_can_buf;
class SAMC21_CAN
{
public:
SAMC21_CAN(uint8_t _CS, uint8_t canid = ID_CAN0, uint8_t cantx = 24, uint8_t group = 0);
uint8_t begin(uint8_t idmodeset, uint32_t speedset, uint8_t clockset);
uint8_t init_Mask(uint8_t num, uint8_t ext, uint32_t ulData); // Initilize Mask(s)
uint8_t init_Mask(uint8_t num, uint32_t ulData); // Initilize Mask(s)
uint8_t init_Filt(uint8_t num, uint8_t ext, uint32_t ulData); // Initilize Filter(s)
uint8_t init_Filt(uint8_t num, uint32_t ulData); // Initilize Filter(s)
uint8_t setMode(uint8_t opMode); // Set operational mode
uint8_t sendMsgBuf(uint32_t id, uint8_t ext, uint8_t len, uint8_t *buf); // Send message to transmit buffer
uint8_t sendMsgBuf(uint32_t id, uint8_t len, uint8_t *buf);
uint8_t readMsgBuf(uint32_t *id, uint8_t *ext, uint8_t *len, uint8_t *buf);
uint8_t readMsgBuf(uint32_t *id, uint8_t *len, uint8_t *buf);
uint8_t checkReceive(void);
uint8_t checkError(void);
uint8_t getError(void);
uint8_t errorCountRX(void);
uint8_t errorCountTX(void);
uint8_t enOneShotTX(void);
uint8_t disOneShotTX(void);
struct mcan_set mcan;
volatile bool rx_ded_buffer_data;
private:
uint32_t mcan_msg_ram[MSG_RAM_SIZE] __attribute__((aligned(4)));
uint32_t mcan_msg_ram_size = ARRAY_SIZE(mcan_msg_ram);
uint8_t _idmode;
uint8_t _mode;
uint8_t _cs;
uint8_t _canid;
uint8_t _cantx;
uint8_t _canrx;
uint8_t _group;
};
#endif //define _SAMC_CAN_H_
| [
"[email protected]"
] | |
b1102477eb8ff2f13e1ad2a0ff49e0438bbcf2d4 | b9face457a0982635ed952071806b94da5ee00e9 | /proj.ios_mac/Touchable.cpp | 30438bfe10f42e1daa22c0866734fb6b100a65a8 | [
"MIT"
] | permissive | Crasader/cheeze | d92e766ac69e6f7f1d3226fac98618c067df81bf | f1a7d375c6831896a7d9b3f7518657da11f28085 | refs/heads/master | 2020-11-29T04:03:06.828517 | 2016-12-09T07:00:49 | 2016-12-09T07:00:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,435 | cpp | #include "Touchable.h"
const std::string Touchable::LONG_TOUCH_KEY = "longTouch";
const float Touchable::LONG_TOUCH_SEC = 1.0f;
void Touchable::onLongTouch(Widget* widget, const Callback& action)
{
widget->setTouchEnabled(true);
widget->addTouchEventListener([&, action](Ref* ref, Widget::TouchEventType eventType){
auto widget = static_cast<Widget*>(ref);
if(eventType == Widget::TouchEventType::BEGAN){
widget->schedule([&, ref, action](float dt){
_dt += dt;
if(_dt > Touchable::LONG_TOUCH_SEC){
_dt = 0;
action(ref);
static_cast<Widget*>(ref)->unschedule(Touchable::LONG_TOUCH_KEY);
}
}, Touchable::LONG_TOUCH_KEY);
}
if(eventType == Widget::TouchEventType::ENDED){
static_cast<Widget*>(ref)->unschedule(Touchable::LONG_TOUCH_KEY);
_dt = 0;
}
});
}
void Touchable::onTouch(Widget* widget, const Callback& action)
{
widget->setTouchEnabled(true);
widget->setSwallowTouches(false);
widget->addTouchEventListener([widget, action](Ref* ref, Widget::TouchEventType eventType){
if(eventType == Widget::TouchEventType::ENDED){
action(ref);
}
});
}
void Touchable::disableTouch(Layer* layer)
{
auto disable = Layout::create();
disable->setTouchEnabled(true);
disable->setContentSize(Director::getInstance()->getWinSize());
disable->addTouchEventListener([](Ref* ref,Widget::TouchEventType eventType){
log("disable touch");
});
disable->setName(DISABLE_TOUCH_LAYER);
layer->addChild(disable);
}
void Touchable::enableTouch(Layer* layer)
{
while(auto disable = layer->getChildByName(DISABLE_TOUCH_LAYER)){
disable->removeFromParent();
}
}
void Touchable::useTouchMaker(Node* node)
{
auto listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan = [](Touch* touch, Event*event){
auto particle = ParticleSystemQuad::create("Particles/touch.plist");
particle->setPosition(touch->getLocation());
event->getCurrentTarget()->addChild(particle);
particle->setAutoRemoveOnFinish(true);
return true;
};
auto layer = Layer::create();
node->addChild(layer);
Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, layer);
}
| [
"[email protected]"
] | |
d02f92efef29da5d0a9abf35771c4f75cc684203 | 5eb01b2eff25fb0d8fbbb00b02961e565ac3f415 | /widgetkit/filteroklineedit.h | 0e4041fae6752bcc4c0026793bcd8a363db3dea7 | [] | no_license | biglone/LT-PureCodes | 3ca6fc47731e2d566cd1c5389cce93e55768933a | 22d7ec1a1414bc99a16a050800a2cc9259546b9a | refs/heads/master | 2020-05-04T10:29:03.603664 | 2019-04-02T14:23:40 | 2019-04-02T14:23:40 | 179,088,457 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 461 | h | #ifndef FILTEROKLINEEDIT_H
#define FILTEROKLINEEDIT_H
#include "widgetkit_global.h"
#include "fancylineedit.h"
class WIDGETKIT_EXPORT FilterOkLineEdit : public FancyLineEdit
{
Q_OBJECT
public:
explicit FilterOkLineEdit(QWidget *parent = 0);
void setClearRightButton();
void setOkRightButton();
signals:
void filterChanged(const QString &);
private slots:
void slotTextChanged();
private:
QString m_lastFilterText;
};
#endif // FILTEROKLINEEDIT_H
| [
"[email protected]"
] | |
3445498614da1cf66142e1b9d2f878906cb86a56 | 82669371970438169ec34783c80f69146b0cb9d2 | /Source/Projet_Aaron/Mutation/AllergyMutation.cpp | e54e57bb4396701e853e10648e447fa3892ff941 | [] | no_license | LeProfyteur/Projet_Aaron | 9a4c0891e5f06e8f2eddcd2d81ed48b98d5ba3b9 | 52f442ec7ad542c3fe95873243ec9d4130ce6d46 | refs/heads/master | 2023-05-21T01:52:49.748079 | 2020-05-25T09:42:49 | 2020-05-25T09:42:49 | 238,959,399 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 327 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "AllergyMutation.h"
UAllergyMutation::UAllergyMutation()
{
}
void UAllergyMutation::OnEquip(FCharacterSkills& Skills)
{
Skills.Allergy = true;
}
void UAllergyMutation::OnUnEquip(FCharacterSkills& Skills)
{
Skills.Allergy = false;
}
| [
"[email protected]"
] | |
60a29403e85effc37b3766a71bc88420a70afc9f | b769870a0bb62ef3dfbe860212fdb70568435128 | /GameAsteroids/GameAsteroids/GameAsteroids.h | 97c4398d99e82e6e33399e6b34a4d2e5374836fd | [] | no_license | smallinsect/MyGame | 50255b092ea75b2d869a1130ed3c79e6bdcc0c07 | 2fdd21567307fd4455d5dbcf3aa9f3234ebd67ad | refs/heads/master | 2021-02-07T08:07:15.108885 | 2021-02-04T14:20:31 | 2021-02-04T14:20:31 | 244,001,107 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 488 | h |
// GameAsteroids.h: PROJECT_NAME 应用程序的主头文件
//
#pragma once
#ifndef __AFXWIN_H__
#error "在包含此文件之前包含 'pch.h' 以生成 PCH"
#endif
#include "resource.h" // 主符号
// CGameAsteroidsApp:
// 有关此类的实现，请参阅 GameAsteroids.cpp
//
class CGameAsteroidsApp : public CWinApp
{
public:
CGameAsteroidsApp();
// 重写
public:
virtual BOOL InitInstance();
// 实现
DECLARE_MESSAGE_MAP()
};
extern CGameAsteroidsApp theApp;
| [
"[email protected]"
] | |
6f0f484e78236393075d77d49f5287df2ecdd9d2 | cedee59c1f3b7322ae08683565555eb2fe15444d | /node_modules/react-native/ReactCommon/fabric/components/view/TouchEvent.h | 86022f2b875aabfc285baaf8d50746f7f6e664b5 | [
"MIT",
"CC-BY-SA-4.0",
"CC-BY-4.0",
"CC-BY-NC-SA-4.0"
] | permissive | ildaneta/nlw-6-game-play | 279eecf6dd20116e83d46f3e7005616ad7601e47 | 646efcc67db37eaf04bb3c452fbf2e4c99f6d5a9 | refs/heads/main | 2023-06-20T19:29:56.023594 | 2021-07-18T00:16:30 | 2021-07-18T00:16:30 | 378,730,034 | 4 | 0 | MIT | 2021-07-18T00:16:30 | 2021-06-20T20:02:14 | TypeScript | UTF-8 | C++ | false | false | 1,266 | h | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <react/debug/DebugStringConvertible.h>
#include <unordered_set>
#include <react/components/view/Touch.h>
namespace facebook {
namespace react {
using Touches = std::unordered_set<Touch, Touch::Hasher, Touch::Comparator>;
/*
* Defines the `touchstart`, `touchend`, `touchmove`, and `touchcancel` event
* types.
*/
struct TouchEvent {
/*
* A list of Touches for every point of contact currently touching the
* surface.
*/
Touches touches;
/*
* A list of Touches for every point of contact which contributed to the
* event.
*/
Touches changedTouches;
/*
* A list of Touches for every point of contact that is touching the surface
* and started on the element that is the target of the current event.
*/
Touches targetTouches;
};
#if RN_DEBUG_STRING_CONVERTIBLE
std::string getDebugName(TouchEvent const &touchEvent);
std::vector<DebugStringConvertibleObject> getDebugProps(
TouchEvent const &touchEvent,
DebugStringConvertibleOptions options);
#endif
} // namespace react
} // namespace facebook
| [
"[email protected]"
] | |
28537fd4e96d3a45f2ee71b1f3cece4b23c7d8ab | 3a0fd458f253a2284cb58608822c108a8601a553 | /CPTTRN1/CPTTRN1-16821829.cpp | 307a8423dc8523398758f75fd05012a8304c9a9f | [] | no_license | shahsid104/Spoj | df87a6017098828c29e0e03965c8be8247e1cec9 | 3f31829d66463b5ecd6623ff724bbb92e2bd88d0 | refs/heads/master | 2021-04-26T15:58:27.894539 | 2016-10-17T16:01:37 | 2016-10-17T16:01:37 | 71,153,790 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 455 | cpp | #include <iostream>
#include<stdio.h>
using namespace std;
int main() {
// your code goes here
int t,r,c;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&r,&c);
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
if(i%2==0)
{
if(j%2!=0)
printf(".");
else
printf("*");
}
else
{
if(j%2!=0)
printf("*");
else
printf(".");
}
}
printf("\n");
}
printf("\n");
}
return 0;
} | [
"Sid Shah"
] | Sid Shah |
f59ce1d898b78f0c07fbec438c773fe0fd376067 | fd54ba386f80bef6d4374bf92e9bddb56a1232c3 | /k2000/k2000App/src/k2000Main.cpp | 7371fb9169916dbc9729179128ca29b9471491b0 | [] | no_license | NSLS-II-CSX/xf23id1-ioc1 | 91bce9f45fea35dbc6fb7b6997b8553ebcf2d274 | 6e0c14c4520cabb1b87b5eb1b250550809426b37 | refs/heads/master | 2021-01-01T04:06:27.806098 | 2016-05-02T20:00:18 | 2016-05-02T20:00:18 | 57,917,438 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 405 | cpp | /* k2000Main.cpp */
/* Author: Marty Kraimer Date: 17MAR2000 */
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include "epicsExit.h"
#include "epicsThread.h"
#include "iocsh.h"
int main(int argc,char *argv[])
{
if(argc>=2) {
iocsh(argv[1]);
epicsThreadSleep(.2);
}
iocsh(NULL);
epicsExit(0);
return(0);
}
| [
"[email protected]"
] | |
5e60912297542abc40297f5fda6bf8155a10b152 | fec81bfe0453c5646e00c5d69874a71c579a103d | /blazetest/src/mathtest/operations/dmatsmatsub/DDbMCa.cpp | 49e2993fbaee64f0ef230284029f38bd257dbe23 | [
"BSD-3-Clause"
] | permissive | parsa/blaze | 801b0f619a53f8c07454b80d0a665ac0a3cf561d | 6ce2d5d8951e9b367aad87cc55ac835b054b5964 | refs/heads/master | 2022-09-19T15:46:44.108364 | 2022-07-30T04:47:03 | 2022-07-30T04:47:03 | 105,918,096 | 52 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 4,200 | cpp | //=================================================================================================
/*!
// \file src/mathtest/operations/dmatsmatsub/DDbMCa.cpp
// \brief Source file for the DDbMCa dense matrix/sparse matrix subtraction math test
//
// Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group 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.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blaze/math/CompressedMatrix.h>
#include <blaze/math/DiagonalMatrix.h>
#include <blaze/math/DynamicMatrix.h>
#include <blazetest/mathtest/Creator.h>
#include <blazetest/mathtest/operations/dmatsmatsub/OperationTest.h>
#include <blazetest/system/MathTest.h>
#ifdef BLAZE_USE_HPX_THREADS
# include <hpx/hpx_main.hpp>
#endif
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running 'DDbMCa'..." << std::endl;
using blazetest::mathtest::TypeA;
using blazetest::mathtest::TypeB;
try
{
// Matrix type definitions
using DDb = blaze::DiagonalMatrix< blaze::DynamicMatrix<TypeB> >;
using MCa = blaze::CompressedMatrix<TypeA>;
// Creator type definitions
using CDDb = blazetest::Creator<DDb>;
using CMCa = blazetest::Creator<MCa>;
// Running tests with small matrices
for( size_t i=0UL; i<=6UL; ++i ) {
for( size_t j=0UL; j<=i*i; ++j ) {
RUN_DMATSMATSUB_OPERATION_TEST( CDDb( i ), CMCa( i, i, j ) );
}
}
// Running tests with large matrices
RUN_DMATSMATSUB_OPERATION_TEST( CDDb( 67UL ), CMCa( 67UL, 67UL, 7UL ) );
RUN_DMATSMATSUB_OPERATION_TEST( CDDb( 128UL ), CMCa( 128UL, 128UL, 16UL ) );
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during dense matrix/sparse matrix subtraction:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
| [
"[email protected]"
] | |
349c03aaaac4b1577bb323d522a1fe32dc2530e3 | 80b509a0d765b36d010558382d361e14c038d79d | /singleton.h | 2af98a8f50cc282408c2c8aaf02f111788c75dc4 | [] | no_license | MalithaDilshan/EMP | a9a7c0dfbd6a1e6261db42891fd6634f62d75a4e | 9a997e6a5ef021261092676bea6c83b3dc9195d8 | refs/heads/master | 2020-03-28T22:30:59.950565 | 2018-09-18T14:56:21 | 2018-09-18T14:56:21 | 149,236,819 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 948 | h | //**********************************************************//
// Use the singleton anti pattern access database securely. //
//**********************************************************//
#ifndef SINGLETON_H
#define SINGLETON_H
#include <iostream>
#include<string>
#include "datahandler.h"
using namespace std;
class Singleton{
private:
static Singleton* sing_object;
static bool instanceFlag;
DataHandler* data_handler_obj;
// By initiating the DataHandler object in private constructor it will initiate one time
Singleton(){
data_handler_obj = new DataHandler();
} // private constructor
public:
~Singleton();
static Singleton* getInstance();
void addWorker(string command, char worker_type, char employee_type);
void getDetails(string command, string id_number);
void removeWorker(string command, string id_number);
void executeCommand(string command);
};
#endif // SINGLETON_H
| [
"[email protected]"
] | |
1a206f36323d6b25411c2db655df1f1e42e4e215 | 3af0a15b5bef3e77dd5e1955a7b14a8b0573c48d | /LeetCode/Count and Say/main.cpp | a8e9aeb9aec8d76f8a540f801d1df7fd9f15c06b | [] | no_license | tinglai/Algorithm-Practice | 7ef98585e52585d6deed92e669c3af767d3e8033 | e51831e43e00e935d19e2a8ca934eede9d1f6367 | refs/heads/master | 2021-01-25T10:29:19.107639 | 2015-06-02T13:09:04 | 2015-06-02T13:09:04 | 25,283,963 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,060 | cpp | #include <iostream>
#include <string>
#include <deque>
using namespace std;
class Solution {
public:
string countAndSay(int n) {
string result;
if(n <= 0) return result;
deque<int> container;
container.push_back(1);
int count;
int val;
int lastElt;
unsigned int size;
for(int i = 0; i < n - 1; i++){
size = container.size();
lastElt = container.front();
count = 0;
for(unsigned int j = 0; j < size; j++){
val = container.front();
container.pop_front();
if(val == lastElt){
count++;
}
else{
container.push_back(count);
container.push_back(lastElt);
lastElt = val;
count = 1;
}
}
container.push_back(count);
container.push_back(lastElt);
}
size = container.size();
for(unsigned int i = 0; i < size; i++){
string temp;
temp = to_string(container.front());
result += temp;
container.pop_front();
}
return result;
}
};
int main(){
int n;
cout << "n = ";
cin >> n;
Solution solt;
string result = solt.countAndSay(n);
cout << result << endl;
}
| [
"[email protected]"
] | |
377271a958f54f71f70d705eb9a13d858d7ae30f | 8ad562972b4e1e165dbf0291ed676fb9c0248be6 | /main.cpp | becd4411a1d8c871d2fa00fe83d64145c0306a60 | [] | no_license | jk5462/cs3113_pong | 63e34496328b0298c178827e4a07c59a46422518 | 8eaa531c1515d8bcfe4a76e56e18129097b40693 | refs/heads/master | 2020-08-01T21:28:40.256068 | 2019-09-28T22:58:32 | 2019-09-28T22:58:32 | 211,121,991 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,561 | cpp | #define GL_SILENCE_DEPRECATION
#ifdef _WINDOWS
#include <GL/glew.h>
#endif
#include <SDL.h>
#include <SDL_opengl.h>
#include <SDL_image.h>
#include "glm/mat4x4.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "ShaderProgram.h"
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#include "Entity.h"
SDL_Window* displayWindow;
bool gameIsRunning = true;
ShaderProgram program;
glm::mat4 viewMatrix, modelMatrix, projectionMatrix;
float lastTicks = 0;
Entity player1, player2, ball;
int winningPlayer = 1;
float defaultColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
float altColor[] = { 1.0f, 0.5f, 1.0f, 1.0f };
float playerVertices[] = { -0.05, -0.75, 0.05, -0.75, 0.05, 0.75, -0.05, -0.75, 0.05, 0.75, -0.05, 0.75 };
float ballVertices[] = { -0.2, -0.2, 0.2, -0.2, 0.2, 0.2, -0.2, -0.2, 0.2, 0.2, -0.2, 0.2 };
GLuint fontTextureID;
GLuint LoadTexture(const char* filePath) {
int w, h, n;
unsigned char* image = stbi_load(filePath, &w, &h, &n, STBI_rgb_alpha);
if (image == NULL) {
std::cout << "Unable to load image. Make sure the path is correct\n";
assert(false);
}
GLuint textureID;
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
stbi_image_free(image);
return textureID;
}
void Initialize() {
SDL_Init(SDL_INIT_VIDEO);
displayWindow = SDL_CreateWindow("Test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(displayWindow);
SDL_GL_MakeCurrent(displayWindow, context);
#ifdef _WINDOWS
glewInit();
#endif
glViewport(0, 0, 640, 480);
program.Load("shaders/vertex.glsl", "shaders/fragment.glsl");
player1.width = 0.1;
player1.height = 1.5;
player2.width = 0.1;
player2.height = 1.5;
ball.width = 0.4;
ball.height = 0.4;
player1.position = glm::vec3(-4.9f, 0.0f, 0.0f);
player1.movement = glm::vec3(0.0f, 0.0f, 0.0f);
player1.speed = 4;
player2.position = glm::vec3(4.9f, 0.0f, 0.0f);
player2.movement = glm::vec3(0.0f, 0.0f, 0.0f);
player2.speed = 4;
ball.position = glm::vec3(0.0f, 0.0f, 0.0f);
ball.movement = glm::vec3(1.0f, 1.0f, 0.0f);
ball.speed = 3;
viewMatrix = glm::mat4(1.0f);
modelMatrix = glm::mat4(1.0f);
projectionMatrix = glm::ortho(-5.0f, 5.0f, -3.75f, 3.75f, -1.0f, 1.0f);
program.SetProjectionMatrix(projectionMatrix);
program.SetViewMatrix(viewMatrix);
program.SetColor(1.0f, 0.0f, 0.0f, 1.0f);
glUseProgram(program.programID);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
}
bool CheckTopBorderCollision(Entity* object) {
return (object->position.y + (object->height / 2.0f)) > 3.75;
}
bool CheckBottomBorderCollision(Entity* object) {
return (object->position.y - (object->height / 2.0f)) < -3.75;
}
bool CheckRightBorderCollision(Entity* object) {
return (object->position.x + (object->width / 2.0f)) > 5;
}
bool CheckLeftBorderCollision(Entity* object) {
return (object->position.x - (object->width / 2.0f)) < -5;
}
bool CheckEntityCollision(Entity* object1, Entity* object2) {
float xdist = fabs(object2->position.x - object1->position.x) - ((object1->width + object2->width) / 2.0f);
float ydist = fabs(object2->position.y - object1->position.y) - ((object1->height + object2->height) / 2.0f);
return (xdist < 0 && ydist < 0);
}
void ProcessInput() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
case SDL_WINDOWEVENT_CLOSE:
gameIsRunning = false;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_SPACE:
// Some sort of action
break;
}
break;
}
}
const Uint8* keys = SDL_GetKeyboardState(NULL);
if (keys[SDL_SCANCODE_W])
{
if (CheckTopBorderCollision(&player1) == false) {
player1.movement.y = 1;
}
else {
player1.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
}
else if (keys[SDL_SCANCODE_S])
{
if (CheckBottomBorderCollision(&player1) == false) {
player1.movement.y = -1;
}
else {
player1.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
}
else {
player1.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
if (keys[SDL_SCANCODE_UP])
{
if (CheckTopBorderCollision(&player2) == false) {
player2.movement.y = 1;
}
else {
player2.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
}
else if (keys[SDL_SCANCODE_DOWN])
{
if (CheckBottomBorderCollision(&player2) == false) {
player2.movement.y = -1;
}
else {
player2.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
}
else {
player2.movement = glm::vec3(0.0f, 0.0f, 0.0f);
}
//Reset ball position
if (keys[SDL_SCANCODE_R])
{
ball.position = glm::vec3(0.0f, 0.0f, 0.0f);
ball.speed = 3;
}
}
void Update() {
float ticks = (float)SDL_GetTicks() / 1000.0f;
float deltaTime = ticks - lastTicks;
lastTicks = ticks;
if (CheckTopBorderCollision(&ball)) {
ball.movement.y *= -1;
}
else if (CheckBottomBorderCollision(&ball)) {
ball.movement.y *= -1;
}
else if (CheckLeftBorderCollision(&ball)) {
ball.position = glm::vec3(0.0f, 0.0f, 0.0f);
ball.speed = 3;
winningPlayer = 2;
}
else if (CheckRightBorderCollision(&ball)) {
ball.position = glm::vec3(0.0f, 0.0f, 0.0f);
ball.speed = 3;
winningPlayer = 1;
}
//Ball gets faster every player entity-ball collision
if (CheckEntityCollision(&ball, &player1)) {
ball.speed += .2;
ball.movement.x *= -1;
}
else if (CheckEntityCollision(&ball, &player2)) {
ball.speed += .2;
ball.movement.x *= -1;
}
ball.Update(deltaTime);
player1.Update(deltaTime);
player2.Update(deltaTime);
}
void Render() {
glClear(GL_COLOR_BUFFER_BIT);
if (winningPlayer == 1) {
player1.Render(&program, playerVertices, altColor);
player2.Render(&program, playerVertices, defaultColor);
}
else {
player1.Render(&program, playerVertices, defaultColor);
player2.Render(&program, playerVertices, altColor);
}
ball.Render(&program, ballVertices, defaultColor);
SDL_GL_SwapWindow(displayWindow);
}
void Shutdown() {
SDL_Quit();
}
int main(int argc, char* argv[]) {
Initialize();
while (gameIsRunning) {
ProcessInput();
Update();
Render();
}
Shutdown();
return 0;
}
| [
"[email protected]"
] | |
89c4425447d85e02583d6d56b1c7a29febff2329 | a4097c439563e70b12af187c63e30a5c57c5f699 | /labs/lab03_build_process/squeak_quack.cc | eec22eb2e417460165a44b6bb36bb3b47a5720b1 | [] | no_license | conorbrown327/Iteration-2 | 47551d0a40eef0c4cc5be9f0323a436c02aa7688 | 96660b4c29350281dec43b2accea6314adad50b5 | refs/heads/master | 2023-06-10T04:04:49.596300 | 2021-04-20T03:36:52 | 2021-04-20T03:36:52 | 381,190,663 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 289 | cc | //
// squeak_quack.cc
//
// Created by Seth Johnson on 2/5/15.
// Copyright (c) 2015 Seth Johnson. All rights reserved.
//
#include "squeak_quack.h"
#include <iostream>
using std::cout;
using std::endl;
void SqueakQuack::Quack() {
cout << "SQUEAK!!" << endl;
}
| [
"[email protected]"
] | |
a9e4eea48226c36bbb6611fc9bbe209e355d48e1 | f7eea41b4bc57b548d547c4406a7bc04c8d9e7d9 | /1030/main.cpp | 0a97c9cbf495529606cfb139c68e4023bb9b5690 | [] | no_license | zhuhui1990/pat_advanced | 7d5e87cbe7dba76d8b7d1864a89851c4052c278a | b8c3afd85efd191baa73c86d311a2d2f74a28356 | refs/heads/master | 2021-05-01T02:25:21.605408 | 2017-01-24T15:11:57 | 2017-01-24T15:11:57 | 79,923,328 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,889 | cpp | #include <iostream>
#include <vector>
using namespace std;
struct Node{
vector<int> neighbour;
vector<int> dist;
vector<int> cost;
};
bool find(const vector<int>& v,const int& j){
for(int i=0;i<v.size();++i){
if(v[i]==j){
return true;
}
}
return false;
}
void DFS(int i,const int& d,int& cost,int& dist,int& mincost,int& mindist,vector<int>& route,const vector<Node>& city,vector<int>& visited){
/*cout<<"i="<<i<<" cost="<<cost<<" dist="<<dist<<" mincost="<<mincost<<" mindist="<<mindist<<endl;
cout<<"visited=";
for(int j=0;j<visited.size();++j){
cout<<visited[j]<<" ";
}
cout<<endl;
*/
if(i==d){
if(dist<mindist ||(dist==mindist && cost<mincost)){
mindist=dist;
mincost=cost;
route=visited;
}
return;
}else{
for(int j=0;j<city[i].neighbour.size();++j){
int jj=city[i].neighbour[j];
//cout<<"jj="<<jj<<" find="<<find(visited,jj)<<endl;
if(find(visited,jj)==false && (cost<mincost ||(cost==mincost && dist<mindist))){
visited.push_back(jj);
dist += city[i].dist[j];
cost += city[i].cost[j];
DFS(jj,d,cost,dist,mincost,mindist,route,city,visited);
visited.pop_back();
dist -= city[i].dist[j];
cost -= city[i].cost[j];
}
}
}
}
int main(){
const int inf=0xffff;
int n,m,s,d;
cin>>n>>m>>s>>d;
vector<Node> city(n);
int c1,c2,dist,cost;
for(int i=0;i<m;++i){
cin>>c1>>c2>>dist>>cost;
city[c1].neighbour.push_back(c2);
city[c1].dist.push_back(dist);
city[c1].cost.push_back(cost);
city[c2].neighbour.push_back(c1);
city[c2].dist.push_back(dist);
city[c2].cost.push_back(cost);
}
vector<int> route;
route.push_back(s);
dist=0;
cost=0;
int mincost=inf;
int mindist=inf;
vector<int> visited;
visited.push_back(s);
DFS(s,d,cost,dist,mincost,mindist,route,city,visited);
for(int i=0;i<route.size();++i){
cout<<route[i]<<" ";
}
cout<<mindist<<" "<<mincost<<endl;
return 0;
} | [
"[email protected]"
] | |
4d4608992a893583b26048568df3fec1b72ebab1 | 8475f2eeaae6e2861b764bfeb79d1603b7bfe233 | /LintCode!/371. 用递归打印数字.cpp | e345806a4d0092a1c413b3329d4bb6481d58fd38 | [] | no_license | danhuang-0/MyLintCode | 82cc2eb01199adcf88c5b56dd66bd01cb6e1e747 | c017247e91e98b4c5ba6465a30ce4f81e4fd358a | refs/heads/master | 2020-03-25T08:30:20.028950 | 2019-01-05T05:18:24 | 2019-01-05T16:47:54 | 143,616,150 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 832 | cpp | //// 递归N层，就需要每一层完成一位的添加
//
//#include <iostream>
//#include <vector>
//
//using namespace std;
//
//class Solution {
//public:
// /**
// * @param n: An integer
// * @return: An array storing 1 to the largest number with n digits.
// */
// void makeNums( vector<int> &vecNums, int nLevel, int nMaxLevel ){
// if( nLevel > nMaxLevel )
// return;
// int nBegin = pow(10, nLevel-1);
// int nEnd = pow(10, nLevel);
// for( int i=nBegin; i<nEnd; i++ ){
// vecNums.push_back(i);
// }
// makeNums( vecNums, nLevel+1, nMaxLevel);
// }
// vector<int> numbersByRecursion(int n) {
// // write your code here
// vector<int> vecRet;
// makeNums( vecRet, 1, n );
// return vecRet;
// }
//};
//
//int main(){
// Solution s;
// s.numbersByRecursion( 6 );
//
// return 0;
//} | [
"[email protected]"
] | |
e55aab3f75ce940f002ab639e7c581faabc10612 | 64579720a172473bd0cfb07de79fd1dd0a8eccd8 | /ConsoleRPG/ItemSystem.cpp | ece0a0ab17bfe4737e044d276f805bfbfc3ebabd | [] | no_license | aliluyou90/consoleRPG | 060a1ad9631161b4f3054f96cbbcedc37fc4fe1d | b66e258e26ee6dbe23c34ec87dbf7c81e8cdcfb5 | refs/heads/master | 2021-01-21T15:58:06.258036 | 2017-05-24T05:15:55 | 2017-05-24T05:15:55 | 91,867,446 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,755 | cpp | #include "stdafx.h"
#include "ItemSystem.h"
ItemSystem::ItemSystem()
{
}
ItemSystem::~ItemSystem()
{
}
void ItemSystem::init(Character* character)
{
this->character = character;
this->state = true;
while (this->state) {
this->itemSysManu();
}
}
void ItemSystem::itemSysManu()
{
this->itemOninfo();
this->inv.invInfo();
cout << " -------------> Select (Item #) or Back(0)" << endl;
choice = 0;
cin >> choice;
if (choice == 0) { this->state = false; }
else if (choice <= this->inv.getNumItem()) {
cout << this->inv[choice-1].debugPrint()<< endl;
int useOrnot = 0;
cout << "\n======= 1:Use Item \n======= 2:Discard Item \n======= Other: Back\n -->";
cin >> useOrnot;
switch(useOrnot){
case 1:
{Item * it = this->inv[choice - 1].useItem(character);
if (it) {
this->inv.addItem(*it);
}
this->inv.removeItem(choice - 1); }
break;
case 2:
this->inv.removeItem(choice - 1);
break;
default:
break;
}
}
}
void ItemSystem::itemOninfo()
{
Item * it;
cout << "===================================================================\n";
it = character->getWeaponOn();
if (it) {
cout << " == Weapon: " +it->getName() << " ";
}
else { cout << " == Weapon: empty" << " "; }
it = character->getHeadOn();
if (it) {
cout << " == Head: " + it->getName() << " ";
}
else { cout << " == Head: empty" << " "; }
it = character->getBodyOn();
if (it) {
cout << " == Body: " + it->getName() << " ";
}
else { cout << " == Body: empty" << " "; }
it = character->getFootOn();
if (it) {
cout << " == Foot: " + it->getName() << " ";
}
else { cout << " == Foot: empty" << " "; }
cout << endl << "===================================================================\n\n";
}
| [
"[email protected]"
] | |
3e766273a1ca30052a684b74a8e2ddd83f987f68 | 86a9081a05b837ad0f0feaf6e003a1cbb276993f | /cg_exercises-cg_exercise_04/04_bvh_v5/cg_exercise_04/cglib/lib/glm/glm/gtx/perpendicular.inl | 0e02509a5bc66a17fbc4a9ea97434678f1c8d996 | [
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-happy-bunny",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | flex3r/cg_exercises | e2defd27427c251d5f0f567a8d192af8d87bca3c | 7c4b699a8211ba66710ac2137f0d460933069331 | refs/heads/master | 2020-12-11T14:06:15.052585 | 2018-02-11T13:58:23 | 2018-02-11T13:58:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | inl | /// @ref gtx_perpendicular
/// @file glm/gtx/perpendicular.inl
namespace glm
{
template <typename vecType>
GLM_FUNC_QUALIFIER vecType perp
(
vecType const & x,
vecType const & Normal
)
{
return x - proj(x, Normal);
}
}//namespace glm
// CG_REVISION 923b9bac8f5225422060a543872d939f9f9f68dd
| [
"[email protected]"
] | |
53c972a128703cb7f5e3554d4debff0ed6e399b5 | a1fe4dc3a7a4911607ac55a2bd7da19b29f36849 | /libnet/net/Socket.h | d98e44556852f503d96733855abbcc9361d406a6 | [] | no_license | Monsterwi/myWebserver | 8964c6773abf637bea85dc2d2e8493590498a7dd | 264dd6079840188f76e39b88404b11edf70939c0 | refs/heads/main | 2023-07-27T03:55:28.671566 | 2021-09-10T14:46:26 | 2021-09-10T14:46:26 | 394,996,851 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,597 | h | #ifndef LIBNET_NET_SOCKET_H
#define LIBNET_NET_SOCKET_H
#include "libnet/base/noncopyable.h"
// struct tcp_info is in <netinet/tcp.h>
struct tcp_info;
namespace libnet
{
///
/// TCP networking.
///
namespace net
{
class InetAddress;
///
/// Wrapper of socket file descriptor.
///
/// It closes the sockfd when desctructs.
/// It's thread safe, all operations are delagated to OS.
class Socket : noncopyable
{
public:
explicit Socket(int sockfd)
: sockfd_(sockfd)
{ }
// Socket(Socket&&) // move constructor in C++11
~Socket();
int fd() const { return sockfd_; }
// return true if success.
bool getTcpInfo(struct tcp_info*) const;
bool getTcpInfoString(char* buf, int len) const;
/// abort if address in use
void bindAddress(const InetAddress& localaddr);
/// abort if address in use
void listen();
/// On success, returns a non-negative integer that is
/// a descriptor for the accepted socket, which has been
/// set to non-blocking and close-on-exec. *peeraddr is assigned.
/// On error, -1 is returned, and *peeraddr is untouched.
int accept(InetAddress* peeraddr);
void shutdownWrite();
///
/// Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
///
void setTcpNoDelay(bool on);
///
/// Enable/disable SO_REUSEADDR
///
void setReuseAddr(bool on);
///
/// Enable/disable SO_REUSEPORT
///
void setReusePort(bool on);
///
/// Enable/disable SO_KEEPALIVE
///
void setKeepAlive(bool on);
private:
const int sockfd_;
};
} // namespace net
} // namespace libnet
#endif // LIBNET_NET_SOCKET_H
| [
"[email protected]"
] | |
9b9963a605c241cb93b700e5ef48117b85ca419c | 6fea8d35315dbf883055bbe7123ea84bad35cec0 | /src/qt/pivx/forms/ui_lockunlock.h | 84bde8d1ec592b097e80909fbc21880c5ef06464 | [
"MIT"
] | permissive | PlutusCapital/core | caef5b3710bda17e062837ad6e4653c78065c318 | 9a02ab820245afdb2b3ab4bea621a78bfef37590 | refs/heads/master | 2023-01-04T01:36:55.766312 | 2020-10-29T09:11:15 | 2020-10-29T09:11:15 | 227,622,200 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,278 | h | /********************************************************************************
** Form generated from reading UI file 'lockunlock.ui'
**
** Created by: Qt User Interface Compiler version 5.5.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_LOCKUNLOCK_H
#define UI_LOCKUNLOCK_H
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_LockUnlock
{
public:
QHBoxLayout *horizontalLayout_3;
QWidget *container;
QVBoxLayout *verticalLayout_2;
QGroupBox *groupBox;
QVBoxLayout *verticalLayout;
QSpacerItem *verticalSpacer;
QHBoxLayout *horizontalLayout_2;
QPushButton *pushButtonUnlocked;
QHBoxLayout *horizontalLayout_31;
QPushButton *pushButtonLocked;
QHBoxLayout *horizontalLayout;
QPushButton *pushButtonStaking;
QSpacerItem *verticalSpacer_2;
void setupUi(QWidget *LockUnlock)
{
if (LockUnlock->objectName().isEmpty())
LockUnlock->setObjectName(QStringLiteral("LockUnlock"));
LockUnlock->resize(528, 141);
LockUnlock->setStyleSheet(QStringLiteral("margin:0px; padding:0px; border:none;"));
horizontalLayout_3 = new QHBoxLayout(LockUnlock);
horizontalLayout_3->setSpacing(0);
horizontalLayout_3->setObjectName(QStringLiteral("horizontalLayout_3"));
horizontalLayout_3->setContentsMargins(0, 0, 0, 0);
container = new QWidget(LockUnlock);
container->setObjectName(QStringLiteral("container"));
verticalLayout_2 = new QVBoxLayout(container);
verticalLayout_2->setSpacing(0);
verticalLayout_2->setObjectName(QStringLiteral("verticalLayout_2"));
verticalLayout_2->setContentsMargins(0, 0, 0, 0);
groupBox = new QGroupBox(container);
groupBox->setObjectName(QStringLiteral("groupBox"));
groupBox->setStyleSheet(QStringLiteral(""));
verticalLayout = new QVBoxLayout(groupBox);
verticalLayout->setSpacing(0);
verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
verticalLayout->setContentsMargins(0, 0, 0, 0);
verticalSpacer = new QSpacerItem(20, 2, QSizePolicy::Minimum, QSizePolicy::Expanding);
verticalLayout->addItem(verticalSpacer);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setObjectName(QStringLiteral("horizontalLayout_2"));
pushButtonUnlocked = new QPushButton(groupBox);
pushButtonUnlocked->setObjectName(QStringLiteral("pushButtonUnlocked"));
pushButtonUnlocked->setMinimumSize(QSize(36, 36));
pushButtonUnlocked->setMaximumSize(QSize(16777215, 36));
pushButtonUnlocked->setCheckable(true);
pushButtonUnlocked->setChecked(true);
pushButtonUnlocked->setAutoExclusive(true);
horizontalLayout_2->addWidget(pushButtonUnlocked);
verticalLayout->addLayout(horizontalLayout_2);
horizontalLayout_31 = new QHBoxLayout();
horizontalLayout_31->setObjectName(QStringLiteral("horizontalLayout_31"));
pushButtonLocked = new QPushButton(groupBox);
pushButtonLocked->setObjectName(QStringLiteral("pushButtonLocked"));
pushButtonLocked->setMinimumSize(QSize(36, 36));
pushButtonLocked->setMaximumSize(QSize(16777215, 36));
pushButtonLocked->setCheckable(true);
pushButtonLocked->setAutoExclusive(true);
horizontalLayout_31->addWidget(pushButtonLocked);
verticalLayout->addLayout(horizontalLayout_31);
horizontalLayout = new QHBoxLayout();
horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
pushButtonStaking = new QPushButton(groupBox);
pushButtonStaking->setObjectName(QStringLiteral("pushButtonStaking"));
pushButtonStaking->setMinimumSize(QSize(36, 36));
pushButtonStaking->setMaximumSize(QSize(16777215, 36));
pushButtonStaking->setCheckable(true);
pushButtonStaking->setAutoExclusive(true);
horizontalLayout->addWidget(pushButtonStaking);
verticalLayout->addLayout(horizontalLayout);
verticalSpacer_2 = new QSpacerItem(20, 2, QSizePolicy::Minimum, QSizePolicy::Minimum);
verticalLayout->addItem(verticalSpacer_2);
verticalLayout_2->addWidget(groupBox);
horizontalLayout_3->addWidget(container);
retranslateUi(LockUnlock);
QMetaObject::connectSlotsByName(LockUnlock);
} // setupUi
void retranslateUi(QWidget *LockUnlock)
{
LockUnlock->setWindowTitle(QApplication::translate("LockUnlock", "Form", 0));
pushButtonUnlocked->setText(QString());
pushButtonLocked->setText(QString());
pushButtonStaking->setText(QString());
} // retranslateUi
};
namespace Ui {
class LockUnlock: public Ui_LockUnlock {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_LOCKUNLOCK_H
| [
"[email protected]"
] | |
8f6dfa39733282746c61fe45745cf5e551d67fd0 | c44fb0847f55d5a9a187e6e9518c1fa28957c480 | /AdvancedLib/DesignPattern/Responsibility/ResponserException.cpp | 7b3cd658c991e28514e6df72828c46a241852670 | [] | no_license | Spritutu/hiquotion_cpp | 54567d5d0e62c36415d94f851ef9631932480e33 | 39e35053f979f7b613075c6a582fe58333c95dff | refs/heads/master | 2022-03-29T13:08:54.752069 | 2020-01-21T05:00:19 | 2020-01-21T05:00:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 641 | cpp | // ResponserException.cpp: implementation of the CResponserException class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Responsibility.h"
#include "ResponserException.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CResponserException::CResponserException(CString errMessage)
: m_errMessage(errMessage)
{
}
CResponserException::~CResponserException()
{
}
| [
"[email protected]"
] | |
325331c0f5172c827918a433c48676f2d11bb5d9 | aa4497758a0690203bb3a40518339947227deb6f | /include/khronos/spirv.hpp | 17e8639499493dd0f1dedd343e8eefcc67a2ad3c | [
"MIT",
"NCSA",
"Apache-2.0"
] | permissive | shichangsheng/llpc | 68592d0f2f8aa499c94d7bb5ac0fb9d08dfbfa8d | b2e47a684ac1ba9bcddfc87afa9d2fffffd15c06 | refs/heads/master | 2023-06-22T00:59:29.012382 | 2021-07-08T10:51:31 | 2021-07-08T10:52:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,966 | hpp | /*
***********************************************************************************************************************
*
* Copyright (c) 2015-2021 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.
*
**********************************************************************************************************************/
/**
***********************************************************************************************************************
* @file spirv.h
* @brief SPIR-V header file: proxy to the real Khronos SPIR-V header.
***********************************************************************************************************************
*/
#pragma once
#if EXTERNAL_SPIRV_HEADERS
#include "unified1/spirv.hpp"
#else
#include "spirv/spirv.hpp"
#endif
#if VKI_KHR_SHADER_INTEGER_DOT_PRODUCT
#include "devext/spv_khr_integer_dot_product.h"
#endif
| [
"[email protected]"
] | |
13f7499782c7d097ee3f142f08ce2ef4f99cce8a | 92c9070dada74ea0b9cba5e66577581365574a50 | /list/list.cpp | cd7402289ed2c6c9296fe34ce9fcf2357bd10ce6 | [] | no_license | antosha417/chukanova2_0 | e4ed15a5d5c58a885c9dca690fa47f058c63e401 | 38fa3e0761553b6ef416cc657d9aec5a355050ee | refs/heads/master | 2020-05-25T19:18:01.135174 | 2018-04-26T17:23:11 | 2018-04-26T17:23:11 | 84,957,831 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,858 | cpp | //
// Created by Nikitos
//
#include <assert.h>
#include <iostream>
#include "list.h"
unsigned list::get_len(){
return len;
}
list::list(){
head = new Node();
len = 0;
}
list::~list(){
for(unsigned i = len - 1; i > 0; --i){
delete_from_num(i);
}
head = nullptr;
}
void list::add_to_num(unsigned num, int value){
assert(len >= num);
Node* current = head->get_next();
for(unsigned i = 0; i < num; i++){
current = current->get_next();
}
Node* new_node = new Node(value, current->get_next());
current->set_next(new_node);
++len;
}
void list::delete_from_num(int num){
assert(len > 0);
num %= len;
Node *current = head->get_next();
for (unsigned i = 0; i < num; i++) {
current = current->get_next();
}
Node *temp = current->get_next();
if(temp == head) {
temp = head->get_next();
current = head;
}
current->set_next(temp->get_next());
delete temp;
--len;
}
void list::dump(){
Node* current = head->get_next();
std::cout<<"<Class list: len="<<len<<"| [ ";
if(len > 0) {
for(unsigned i = 0; i < len - 1; i++){
std::cout<<current->get_value()<<", ";
current = current->get_next();
}
std::cout<<current->get_value();
}
std::cout<<" ]>";
std::cout<<std::endl;
}
void list::counter(int c){
Node* current = head;
while (get_len() != 1) {
for (int i = 0; i < c - 1; i++){
current = current->get_next();
if (current == head)
i--;
}
Node* temp = current->get_next();
if (temp == head){
current = head;
temp = head->get_next();
}
current->set_next(temp->get_next());
delete temp;
len --;
dump();
}
} | [
"[email protected]"
] | |
198e3ef946ff5fff4b5ac4623cc115dc07cae520 | f18c89e9cea4eef1bad741ec21bde571b2cf4843 | /SplashScreenStarter/SplashScreenStarter.cpp | 60993e1256f5819e209760d882e3fcbef9545de0 | [] | no_license | razdavidovich/Assembly-Software | e36c5e16d1ae50486928b911e4275302f0579faf | 0ada1c89b737e02e677ba013f61deca9597eb7e3 | refs/heads/master | 2023-06-01T06:31:22.017198 | 2021-08-08T07:53:24 | 2021-08-08T07:53:24 | 100,573,675 | 1 | 0 | null | 2023-05-11T15:11:41 | 2017-08-17T07:17:58 | TSQL | UTF-8 | C++ | false | false | 2,772 | cpp | // SplashScreenStarter.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "SplashScreenStarter.h"
#include "SplashScreen.h"
#include "Objidl.h"
#include <iostream>
#include <string>
#include "ResourceImageLoader.h"
#include "shlwapi.h"
#include "FileImageLoader.h"
#include <windows.h>
#include <stdio.h>
#include <shellapi.h>
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow) {
LPWSTR *szArglist;
LPWSTR lpEXE_FileName = NULL;
LPWSTR lpImage_FileName = NULL;
int nArgs;
szArglist = CommandLineToArgvW(lpCmdLine, &nArgs);
if( NULL == szArglist )
{
exit(1);
}
else
{
if (nArgs = 2)
{
lpEXE_FileName = szArglist[0];
lpImage_FileName = szArglist[1];
}
else
{
exit(1);
}
}
CSplashScreen splash(
hInstance,
// Length of time in milliseconds to display splashscreen fading
3000,
// Specifies the way to load the image for the splashscreen
// To load from the resources, as we have done here, provide the
// resource name and the resource type name. We have used a jpg.
// If you use a PNG, its opacity should be honored to allow you
// to display partially transparent splashscreens.
// To edit the resources in a C++ application go to the resource
// view tab
// To load from a file use this line instead, where filename is the file
// you wish to load:
new CFileImageLoader(lpImage_FileName),
//new CResourceImageLoader(MAKEINTRESOURCE(IDR_SPLASH), _T("JPG")),
// Application prefix. This will be added to the event name so there are no
// conflicts between applications.
_T("SplashScreenStarter"),
// File name of your executable to run. The extension does not need to be .exe.
// If you want to stop your users from starting your application without displaying
// the splashscreen you could use a different extension.
// Is assumed it is in the same folder as this program
// If it is not you can call splash.SetFullPath
lpEXE_FileName
) ;
#ifdef _DEBUG
// In debug mode you may wish to a specify a full path to the application as it may not
// be in your output folder to run using a relative path
//splash.SetFullPath(_T("D:\\projectswpf\\SplashScreen\\SplashScreenTester.exe"));
#endif
splash.Show();
// Free memory allocated for CommandLineToArgvW arguments.
LocalFree(szArglist);
}
// in WPF code
//private void CloseSplashScreen()
//{
// // signal the native process (that launched us) to close the splash screen
// using (var closeSplashEvent = new EventWaitHandle(false,
// EventResetMode.ManualReset, "CloseSplashScreenEvent"+Prefix))
// {
// closeSplashEvent.Set();
// }
//}
| [
"[email protected]"
] | |
9c69e6568618052eb5d215c27506f133fe9f0056 | 9aea4ff0d16c58c5f81dbf1b171f67e268dcd1be | /Angine/Mesh.cpp | 38c76d9cf6afb044e2cef39ad74e96c4e6ba2ab1 | [] | no_license | sssilver/angine | aca8f3a4ce4c4a5ba06b60f42b1eaadb49eda0c6 | 6591e6798868014b4d8676cbdf261e3ce5632a0d | refs/heads/master | 2016-09-05T17:57:11.710096 | 2013-02-15T03:52:12 | 2013-02-15T03:52:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,174 | cpp | #include "Mesh.h"
Mesh::Mesh(void) :
m_vertexBuffer(0),
m_indexBuffer(0)
{
}
Mesh::~Mesh(void)
{
}
bool Mesh::initialize(ID3D11Device* device)
{
return this->initializeBuffers(device);
}
void Mesh::shutdown()
{
this->shutdownBuffers();
}
void Mesh::render(ID3D11DeviceContext* deviceContext)
{
// Put the vertex and index buffers on the graphics pipeline to prepare them for drawing.
this->renderBuffers(deviceContext);
}
const int Mesh::getIndexCount()
{
return this->m_indexCount;
}
bool Mesh::initializeBuffers(ID3D11Device* device)
{
VertexType* vertices;
unsigned long* indices;
D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc;
D3D11_SUBRESOURCE_DATA vertexData, indexData;
HRESULT result;
// Set the number of vertices in the vertex array.
m_vertexCount = 8;
// Set the number of indices in the index array.
m_indexCount = 24;
// Create the vertex array.
vertices = new VertexType[m_vertexCount];
if (!vertices)
return false;
// Create the index array.
indices = new unsigned long[m_indexCount];
if (!indices)
return false;
// Load the vertex array with data.
vertices[0].position = D3DXVECTOR3(-1.0f, 1.0f, 1.0f);
vertices[1].position = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
vertices[2].position = D3DXVECTOR3(-1.0f, -1.0f, 1.0f);
vertices[3].position = D3DXVECTOR3(1.0f, -1.0f, 1.0f);
vertices[4].position = D3DXVECTOR3(-1.0f, 1.0f, -1.0f);
vertices[5].position = D3DXVECTOR3(1.0f, 1.0f, -1.0f);
vertices[6].position = D3DXVECTOR3(-1.0f, -1.0f, -1.0f);
vertices[7].position = D3DXVECTOR3(1.0f, -1.0f, -1.0f);
vertices[0].color = D3DXVECTOR4(1.0f, 1.0f, .0f, .0f);
vertices[1].color = D3DXVECTOR4(.0f, 1.0f, .0f, .0f);
vertices[2].color = D3DXVECTOR4(.0f, 1.0f, 1.0f, .0f);
vertices[3].color = D3DXVECTOR4(1.0f, .0f, .0f, .0f);
vertices[4].color = D3DXVECTOR4(1.0f, .0f, .0f, .0f);
vertices[5].color = D3DXVECTOR4(1.0f, .0f, 1.0f, .0f);
vertices[6].color = D3DXVECTOR4(.0f, 1.0f, .0f, .0f);
vertices[7].color = D3DXVECTOR4(.0f, .0f, 1.0f, .0f);
// Load the index array with data.
indices[0] = 0; indices[1] = 1; indices[2] = 2; indices[3] = 3;
indices[4] = 1; indices[5] = 5; indices[6] = 3; indices[7] = 7;
indices[8] = 5; indices[9] = 4; indices[10] = 7; indices[11] = 6;
indices[12] = 4; indices[13] = 0; indices[14] = 6; indices[15] = 2;
indices[16] = 2; indices[17] = 6; indices[18] = 3; indices[19] = 7;
indices[20] = 5; indices[21] = 1; indices[22] = 4; indices[23] = 0;
// Set up the description of the static vertex buffer.
vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
vertexBufferDesc.MiscFlags = 0;
vertexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the vertex data.
vertexData.pSysMem = vertices;
vertexData.SysMemPitch = 0;
vertexData.SysMemSlicePitch = 0;
// Now create the vertex buffer.
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
if (FAILED(result))
return false;
// Set up the description of the static index buffer.
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
indexBufferDesc.CPUAccessFlags = 0;
indexBufferDesc.MiscFlags = 0;
indexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the index data.
indexData.pSysMem = indices;
indexData.SysMemPitch = 0;
indexData.SysMemSlicePitch = 0;
// Create the index buffer.
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
if (FAILED(result))
return false;
// Release the arrays now that the vertex and index buffers have been created and loaded.
delete [] vertices;
vertices = 0;
delete [] indices;
indices = 0;
return true;
}
void Mesh::shutdownBuffers()
{
// Release the index buffer.
if (m_indexBuffer) {
m_indexBuffer->Release();
m_indexBuffer = 0;
}
// Release the vertex buffer.
if (m_vertexBuffer) {
m_vertexBuffer->Release();
m_vertexBuffer = 0;
}
return;
}
void Mesh::renderBuffers(ID3D11DeviceContext* deviceContext)
{
unsigned int stride;
unsigned int offset;
// Set vertex buffer stride and offset.
stride = sizeof(VertexType);
offset = 0;
// Set the vertex buffer to active in the input assembler so it can be rendered.
deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
// Set the index buffer to active in the input assembler so it can be rendered.
deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set the type of primitive that should be rendered from this vertex buffer, in this case triangles.
deviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
return;
}
| [
"[email protected]"
] | |
45f8d9898f3671d1d6f2ac69f50757766b711acc | 3fc1ee94ebece7022c99d69cad39c3710487a74a | /chrome/common/chrome_features.h | 0d98206e837d7a3b1d2ebe0e389e7518c3f5533a | [
"BSD-3-Clause"
] | permissive | vseal001/chromium | b78653699caa6d54f45401ad0d9e3e90c160b8fb | 474eca05898d2524072c2e3d962a866ddcfe37fc | refs/heads/master | 2023-01-15T05:05:41.728378 | 2018-08-07T12:38:42 | 2018-08-07T12:38:42 | 143,872,860 | 0 | 1 | null | 2018-08-07T12:52:25 | 2018-08-07T12:52:25 | null | UTF-8 | C++ | false | false | 9,915 | h | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file defines all the public base::FeatureList features for the chrome
// module.
#ifndef CHROME_COMMON_CHROME_FEATURES_H_
#define CHROME_COMMON_CHROME_FEATURES_H_
#include "base/feature_list.h"
#include "build/build_config.h"
#include "build/buildflag.h"
#include "chrome/common/buildflags.h"
#include "device/vr/buildflags/buildflags.h"
#include "extensions/buildflags/buildflags.h"
#include "ppapi/buildflags/buildflags.h"
#include "printing/buildflags/buildflags.h"
#include "ui/base/ui_features.h"
namespace features {
// All features in alphabetical order. The features should be documented
// alongside the definition of their values in the .cc file.
extern const base::Feature kAdsFeature;
#if defined(OS_ANDROID)
extern const base::Feature kAllowAutoplayUnmutedInWebappManifestScope;
#endif // defined(OS_ANDROID)
#if defined(OS_MACOSX)
extern const base::Feature kAppleScriptExecuteJavaScriptMenuItem;
extern const base::Feature kShow10_9ObsoleteInfobar;
extern const base::Feature kViewsTaskManager;
#endif // defined(OS_MACOSX)
#if !defined(OS_ANDROID)
extern const base::Feature kAnimatedAppMenuIcon;
extern const base::Feature kAppBanners;
#endif // !defined(OS_ANDROID)
#if defined(OS_ANDROID)
extern const base::Feature kAppNotificationStatusMessaging;
#endif // defined(OS_ANDROID)
extern const base::Feature kAssetDownloadSuggestionsFeature;
extern const base::Feature kAsyncDns;
#if defined(OS_WIN) || defined(OS_MACOSX)
extern const base::Feature kAutomaticTabDiscarding;
#endif // defined(OS_WIN) || defined(OS_MACOSX)
#if defined(OS_WIN) || defined(OS_LINUX)
extern const base::Feature kBackgroundModeAllowRestart;
#endif // defined(OS_WIN) || defined(OS_LINUX)
extern const base::Feature kBlockPromptsIfDismissedOften;
extern const base::Feature kBlockPromptsIfIgnoredOften;
#if defined(OS_MACOSX)
extern const base::Feature kBookmarkApps;
#endif
extern const base::Feature kBrowserHangFixesExperiment;
#if defined(OS_MACOSX)
extern const base::Feature kBrowserTouchBar;
#endif
extern const base::Feature kBundledConnectionHelpFeature;
#if defined(OS_MACOSX)
extern const base::Feature kDialogTouchBar;
extern const base::Feature kTabStripKeyboardFocus;
#endif // defined(OS_MACOSX)
#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_MACOSX)
extern const base::Feature kCertDualVerificationTrialFeature;
#endif
extern const base::Feature kChangePictureVideoMode;
#if defined(OS_ANDROID)
extern const base::Feature kClearOldBrowsingData;
#endif
extern const base::Feature kClickToOpenPDFPlaceholder;
extern const base::Feature kClipboardContentSetting;
extern const base::Feature kCloseButtonsInactiveTabs;
#if defined(OS_MACOSX)
extern const base::Feature kContentFullscreen;
#endif
#if defined(OS_CHROMEOS)
extern const base::Feature kCrostini;
extern const base::Feature kUsageTimeLimitPolicy;
#endif
#if defined(OS_WIN)
extern const base::Feature kDesktopIOSPromotion;
#endif // defined(OS_WIN)
extern const base::Feature kDesktopPWAWindowing;
extern const base::Feature kDesktopPWAsLinkCapturing;
extern const base::Feature kDisallowUnsafeHttpDownloads;
extern const char kDisallowUnsafeHttpDownloadsParamName[];
#if !defined(OS_ANDROID)
extern const base::Feature kDoodlesOnLocalNtp;
#endif
#if defined(OS_ANDROID)
extern const base::Feature kDownloadsForeground;
#endif
#if defined(OS_ANDROID)
extern const base::Feature kDownloadsLocationChange;
#endif
extern const base::Feature kExperimentalAppBanners;
#if defined(OS_CHROMEOS)
extern const base::Feature kExperimentalCrostiniUI;
#endif
extern const base::Feature kExternalExtensionDefaultButtonControl;
// Android expects this string from Java code, so it is always needed.
// TODO(crbug.com/731802): Use #if BUILDFLAG(ENABLE_VR_BROWSING) instead.
#if BUILDFLAG(ENABLE_VR) || defined(OS_ANDROID)
extern const base::Feature kVrBrowsing;
#endif
#if BUILDFLAG(ENABLE_VR)
extern const base::Feature kVrBrowsingExperimentalFeatures;
extern const base::Feature kVrBrowsingExperimentalRendering;
#if BUILDFLAG(ENABLE_OCULUS_VR)
extern const base::Feature kOculusVR;
#endif // ENABLE_OCULUS_VR
#if BUILDFLAG(ENABLE_OPENVR)
extern const base::Feature kOpenVR;
#endif // ENABLE_OPENVR
#endif // ENABLE_VR
extern const base::Feature kFullscreenExitUI;
#if defined(OS_MACOSX)
extern const base::Feature kFullscreenToolbarReveal;
#endif
#if defined(OS_WIN)
extern const base::Feature kGdiTextPrinting;
#endif
extern const base::Feature kGeoLanguage;
#if defined(OS_ANDROID)
extern const base::Feature kGrantNotificationsToDSE;
#endif
#if defined(OS_CHROMEOS)
extern const base::Feature kHappinessTrackingSystem;
#endif
#if !defined(OS_ANDROID)
extern const base::Feature kViewsCastDialog;
#endif
extern const base::Feature kIdnNavigationSuggestions;
extern const base::Feature kImprovedRecoveryComponent;
#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
extern const base::Feature kIncompatibleApplicationsWarning;
#endif
#if !defined(OS_ANDROID)
extern const base::Feature kLocalScreenCasting;
#endif
extern const base::Feature kLsdPermissionPrompt;
#if defined(OS_MACOSX)
extern const base::Feature kMacRTL;
extern const base::Feature kMacFullSizeContentView;
#endif
#if defined(OS_MACOSX)
extern const base::Feature kMacMaterialDesignDownloadShelf;
#endif
#if BUILDFLAG(ENABLE_EXTENSIONS)
extern const base::Feature kAcknowledgeNtpOverrideOnDeactivate;
#endif
#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
extern const base::Feature kWarnBeforeQuitting;
#endif
extern const base::Feature kMaterialDesignIncognitoNTP;
extern const base::Feature kModalPermissionPrompts;
#if BUILDFLAG(ENABLE_NATIVE_NOTIFICATIONS)
extern const base::Feature kNativeNotifications;
#endif
extern const base::Feature kNetworkPrediction;
#if defined(OS_POSIX)
extern const base::Feature kNtlmV2Enabled;
#endif
extern const base::Feature kOfflinePageDownloadSuggestionsFeature;
#if defined(OS_ANDROID)
extern const base::Feature kOomIntervention;
#endif
#if !defined(OS_ANDROID)
extern const base::Feature kOneGoogleBarOnLocalNtp;
#endif
extern const base::Feature kUseNewAcceptLanguageHeader;
extern const base::Feature kPermissionDelegation;
#if defined(OS_WIN)
extern const base::Feature kDisablePostScriptPrinting;
#endif
#if !defined(OS_ANDROID)
extern const base::Feature kPolicyTool;
#endif
#if BUILDFLAG(ENABLE_PLUGINS)
extern const base::Feature kPreferHtmlOverPlugins;
#endif
#if defined(OS_CHROMEOS)
extern const base::Feature kPreloadLockScreen;
#endif
#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
extern const base::Feature kCloudPrinterHandler;
extern const base::Feature kNewPrintPreview;
extern const base::Feature kNupPrinting;
#endif
extern const base::Feature kPushMessagingBackgroundMode;
#if !defined(OS_ANDROID)
extern const base::Feature kRemoveUsageOfDeprecatedGaiaSigninEndpoint;
#endif
extern const base::Feature kSafeSearchUrlReporting;
extern const base::Feature kSecurityKeyAttestationPrompt;
#if defined(OS_MACOSX)
extern const base::Feature kShowAllDialogsWithViewsToolkit;
#endif
#if defined(OS_ANDROID)
extern const base::Feature kShowTrustedPublisherURL;
#endif
extern const base::Feature kSiteSettings;
extern const base::Feature kSitePerProcess;
extern const base::Feature kSitePerProcessOnlyForHighMemoryClients;
extern const char kSitePerProcessOnlyForHighMemoryClientsParamName[];
extern const base::Feature kSSLCommittedInterstitials;
#if defined(OS_CHROMEOS)
extern const base::Feature kNativeSmb;
#endif
extern const base::Feature kSingleTabMode;
extern const base::Feature kSoundContentSetting;
extern const base::Feature kSupervisedUserCommittedInterstitials;
#if defined(OS_CHROMEOS)
extern const base::Feature kSysInternals;
#endif
#if !defined(OS_ANDROID)
extern const base::Feature kTabMetricsLogging;
#endif
#if defined(OS_MACOSX)
extern const base::Feature kTextSuggestionsTouchBar;
#endif
#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
extern const base::Feature kThirdPartyModulesBlocking;
#endif
extern const base::Feature kTopSitesFromSiteEngagement;
extern const base::Feature kUseGoogleLocalNtp;
#if defined(OS_CHROMEOS)
extern const base::Feature kAdaptiveScreenBrightnessLogging;
extern const base::Feature kUserActivityEventLogging;
extern const base::Feature kUserActivityPrediction;
#endif
extern const base::Feature kUseSameCacheForMedia;
#if !defined(OS_ANDROID)
extern const base::Feature kVoiceSearchOnLocalNtp;
#endif
#if defined(OS_CHROMEOS)
extern const base::Feature kArcCupsApi;
extern const base::Feature kOptInImeMenu;
extern const base::Feature kQuickUnlockPin;
extern const base::Feature kQuickUnlockPinSignin;
extern const base::Feature kQuickUnlockFingerprint;
extern const base::Feature kEHVInputOnImeMenu;
extern const base::Feature kBulkPrinters;
extern const base::Feature kCrosCompUpdates;
extern const base::Feature kCrOSComponent;
extern const base::Feature kTPMFirmwareUpdate;
extern const base::Feature kCrOSEnableUSMUserService;
extern const base::Feature kMachineLearningService;
extern const base::Feature kUsbguard;
#endif // defined(OS_CHROMEOS)
#if !defined(OS_ANDROID)
extern const base::Feature kWebRtcRemoteEventLog;
extern const base::Feature kWebRtcRemoteEventLogGzipped;
#endif
#if defined(OS_WIN)
extern const base::Feature kWin10AcceleratedDefaultBrowserFlow;
#endif // defined(OS_WIN)
#if defined(OS_ANDROID)
extern const base::Feature kIncognitoStrings;
#endif // defined(OS_ANDROID)
bool PrefServiceEnabled();
// DON'T ADD RANDOM STUFF HERE. Put it in the main section above in
// alphabetical order, or in one of the ifdefs (also in order in each section).
} // namespace features
#endif // CHROME_COMMON_CHROME_FEATURES_H_
| [
"[email protected]"
] | |
8e9f4170bbd19b3be99bfd23e55cf798e9eb6206 | 2ff43b5f55285bd9f0bc243ed81bfda1d75bdc27 | /8.其他/机器人抓取/重构/NCC/squirrel_perception_backup-hydro_dev/v4r/v4r/AttentionModule/example/ExmplMSR.cpp | 7895be9244013f0fcb307409d112c7f4fadbf26e | [] | no_license | Ivan-VV/3D-ObjectDetection-and-Pose-Estimation | 876d343aa5011228e15a43cb999586b09bfa313d | 4fbe1c32fcd0618ab237eaa12931626c8d88c4ac | refs/heads/master | 2022-02-20T03:27:58.829378 | 2019-06-17T06:51:48 | 2019-06-17T06:51:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,757 | cpp | /**
* Copyright (C) 2012
* Ekaterina Potapova
* Automation and Control Institute
* Vienna University of Technology
* Gusshausstraße 25-29
* 1040 Vienna, Austria
* potapova(at)acin.tuwien.ac.at
*
* 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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://www.gnu.org/licenses/
*/
#include <opencv2/opencv.hpp>
#include "v4r/AttentionModule/AttentionModule.hpp"
#include "v4r/EPUtils/EPUtils.hpp"
// This program shows the use of MSR to extract attention points
void printUsage(const char *argv0)
{
printf(
"Extracts attention points using MSR\n"
"usage: %s image.png saliency.png points.txt points.png useMorphologyOpenning\n"
" image.png ... color image\n"
" saliency.png ... saliency image\n"
" points.txt ... output text file with points\n"
" points.png ... output image with points\n"
" useMorphologyOpenning ... 0 -- useMorphologyOpenning = false; !=0 -- useMorphologyOpenning = true\n", argv0);
printf(" Example: %s 1 image.png saliency.png points.txt points.png 0\n",argv0);
}
int main(int argc, char** argv)
{
srand ( time(NULL) );
if(argc != 6)
{
printUsage(argv[0]);
return(0);
}
std::string image_name(argv[1]);
std::string map_name(argv[2]);
std::string output_file_name(argv[3]);
std::string output_png_name(argv[4]);
int useMorphologyOpenning = atoi(argv[5]);
// read image
cv::Mat image = cv::imread(image_name,-1);
// read saliency map
cv::Mat saliencyMap = cv::imread(map_name,0);
saliencyMap.convertTo(saliencyMap,CV_32F,1.0/255);
AttentionModule::MRSParams msrParams;
AttentionModule::defaultParamsMSR(msrParams);
//modify wta
msrParams.useMorphologyOpenning = (useMorphologyOpenning == 0 ? false : true);
std::vector<cv::Point> attentionPoints;
attentionPoints.clear();
AttentionModule::detectMSR(attentionPoints,saliencyMap,msrParams);
EPUtils::writeAttentionPoints(attentionPoints,output_file_name);
//save image with attantion points
EPUtils::drawAttentionPoints(image,attentionPoints,10);
cv::imwrite(output_png_name,image);
//cv::waitKey();
return(0);
} | [
"[email protected]"
] | |
32d9281ebae8e1f95d6bf723303b8176ba512aea | d7daa1c9473ed169db03c0a84581cfb20253a3d0 | /src/modules/file-formats/BMP/BMPModule.h | e1f00a0b80468cfc6ac4e176b4adb21e3ec002fa | [
"LicenseRef-scancode-other-permissive"
] | permissive | ksAlpha001/PCL | 8986a360478ae8d1b01491efb81df5308ddb21a6 | 5c2d45a4b5a9fceacc0be08dc07d9100f19b0b7b | refs/heads/master | 2023-03-15T01:48:32.964335 | 2017-05-01T08:50:05 | 2017-05-01T08:50:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,736 | h | // ____ ______ __
// / __ \ / ____// /
// / /_/ // / / /
// / ____// /___ / /___ PixInsight Class Library
// /_/ \____//_____/ PCL 02.01.03.0819
// ----------------------------------------------------------------------------
// Standard BMP File Format Module Version 01.00.03.0285
// ----------------------------------------------------------------------------
// BMPModule.h - Released 2017-04-14T23:07:02Z
// ----------------------------------------------------------------------------
// This file is part of the standard BMP PixInsight module.
//
// Copyright (c) 2003-2017 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. All 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.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
// of their contributors, may be used to endorse or promote products derived
// from this software without specific prior written permission. For written
// permission, please contact [email protected].
//
// 4. All products derived from this software, in any form whatsoever, must
// reproduce the following acknowledgment in the end-user documentation
// and/or other materials provided with the product:
//
// "This product is based on software from the PixInsight project, developed
// by Pleiades Astrophoto and its contributors (http://pixinsight.com/)."
//
// Alternatively, if that is where third-party acknowledgments normally
// appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS 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 PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) 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 __BMPModule_h
#define __BMPModule_h
#include <pcl/MetaModule.h>
namespace pcl
{
// ----------------------------------------------------------------------------
class BMPModule : public MetaModule
{
public:
BMPModule();
virtual const char* Version() const;
virtual IsoString Name() const;
virtual String Description() const;
virtual String Company() const;
virtual String Author() const;
virtual String Copyright() const;
virtual String TradeMarks() const;
virtual String OriginalFileName() const;
virtual void GetReleaseDate( int& year, int& month, int& day ) const;
};
// ----------------------------------------------------------------------------
} // pcl
#endif // __BMPModule_h
// ----------------------------------------------------------------------------
// EOF BMPModule.h - Released 2017-04-14T23:07:02Z
| [
"[email protected]"
] | |
a9b88935ecfbefa7b4212df2bd9ce6431918fe80 | 8f4aaf0620634d2ba574249e6cd219628df2cda2 | /IntegralFunc.cpp | c7b5510c90e454e5ee4d6b6ee817745bb5f6aaf7 | [] | no_license | moevm/gui-1h2018-27 | 3ab64ce282535cd87e8f9f5093f63819f3a6b1c0 | 84c10b8f223f1368d69bdfe3c254ddc5d6b95072 | refs/heads/master | 2021-01-25T11:39:14.822305 | 2018-05-05T23:02:47 | 2018-05-05T23:02:47 | 123,413,585 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 979 | cpp | #include "stdafx.h"
#include <string>
#include <iostream>
using namespace std;
double value_at_a_point(string string, int& counter, double x, int& brct, bool& error);
double Integral(string string, double a, double b){
bool error = false;
double res = 0;
int counter = 0;
int brct = 0;
double help1, help2, help3;
const int n = 10000; // количество точек. Влияет на скорость работы.
double x[n+1] = { 0 };
x[0] = a;
double h = (b - a) / n;
for (int i = 1; i < n+1 ; ++i){
x[i] = x[i - 1] + h;
}
for (int k = 1; k < n; k = k + 2){
counter = 0;
brct = 0;
help1 = value_at_a_point(string, counter, x[k - 1], brct, error);
if (error) return -1000; // error
counter = 0;
brct = 0;
help2 = value_at_a_point(string, counter, x[k], brct, error);
counter = 0;
brct = 0;
help3 = value_at_a_point(string, counter, x[k + 1], brct, error);
res = res + help1 + 4 * help2 + help3;
}
res = res * h / 3;
return res;
} | [
"[email protected]"
] | |
16e9703a0076b8cccabd38bc098b75eeb263c9a1 | 41778ded99c3d573661983be345a325f1ec1115a | /caen.h | 219697efd48e6761ad53fca47ce027639044f8d2 | [] | no_license | ChronoBro/sort_7Li | f27f600c9876f7ac79cb665394b3949d68312401 | 5fb4338b5c9fdf690e0d6582eff953ca2956a11a | refs/heads/master | 2021-01-20T21:11:47.498108 | 2019-08-12T17:09:01 | 2019-08-12T17:09:01 | 60,623,927 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 546 | h | #ifndef CAEN
#define CAEN
#include <cstdlib>
/**
* !\brief handles the readout from a CAEN ADC,QDC,TDC
*
* This class deals with the read out from a number of
* CAEN VME modules
*/
class caen
{
public:
unsigned short number; // number of converted channels
unsigned short crate; // crate number
unsigned short geographic; // geagraphic address of module
unsigned short channel[32];
unsigned short data[32];
unsigned short underflow[32];
unsigned short overflow[32];
unsigned short * read(unsigned short *);
};
#endif
| [
"[email protected]"
] | |
9d8fd7b470d77ef9f7c4e904933405b630a1b060 | 25a70cb81e4d31fe4a71b8bec63c21089d88e0bf | /libsrc/spatialdata/spatialdb/SCECCVMH.icc | be11126c1cd349c0e7f25359193693bd1ba813e3 | [
"MIT"
] | permissive | koson/spatialdata | d7edd00b9dc086ba4cf279b63fbbafae69eed7ba | 5614ed4c00d96f3d4266891d4be3050b4b4a5ccf | refs/heads/master | 2021-01-14T12:27:39.417439 | 2015-05-18T18:38:52 | 2015-05-18T18:38:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,176 | icc | // -*- C++ -*-
//
// ----------------------------------------------------------------------
//
// Brad T. Aagaard, U.S. Geological Survey
//
// This code was developed as part of the Computational Infrastructure
// for Geodynamics (http://geodynamics.org).
//
// Copyright (c) 2010-2015 University of California, Davis
//
// See COPYING for license information.
//
// ----------------------------------------------------------------------
//
#if !defined(spatialdata_spatialdb_sceccvmh_hh)
#error "SCECCVMH.icc must only be included from SCECCVMH.hh"
#endif
// Set directory containing SCEC CVM-H data files.
inline
void
spatialdata::spatialdb::SCECCVMH::dataDir(const char* dir) {
_dataDir = dir;
}
// Set squashed topography/bathymetry flag and minimum elevation of
inline
void
spatialdata::spatialdb::SCECCVMH::squash(const bool flag,
const double limit) {
_squashTopo = flag;
_squashLimit = limit;
}
// Compute minimum Vp from minimum Vs.
inline
double
spatialdata::spatialdb::SCECCVMH::_minVp(void) const {
// Use inverse of nominal Vp->Vs relation to compute minimum Vp.
const double minVp = 1360.0 + 1.16 * _minVs;
return minVp;
}
// End of file
| [
"[email protected]"
] | |
159dac52d7d8b4be8518c2b3d0edd2ea96b79686 | a3c2787f52301dee40a9064e084bb8a157967e83 | /数据结构代码/第二章（线性表和链表）/第一次acm计算/acm下多项式问题（综合）.cpp | a9107d37cb47af9d5d8aedbe9532a9fac29c4325 | [] | no_license | welkin-qing/C | 509ea3807d84fe983be38c8c1c178bc7370008f7 | a812e1e1688b421a36f5645c1c1e37166bf5210c | refs/heads/master | 2020-03-17T20:49:34.799686 | 2018-07-17T06:35:50 | 2018-07-17T06:35:50 | 133,930,240 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 6,371 | cpp | /*
#include<stdio.h>
#include <stdlib.h>
typedef struct node
{
float coef;
int expn;
struct node *next;
}node;
//建立多项式
node *createpoly(int m)
{
node *head,*s,*r;
int e,i=0;
float c;
head = (node *)malloc(sizeof(node));
r = head;
scanf("(%f,%d)",&c,&e);
while(i!=m)
{
s = (node *)malloc(sizeof(node));
s->coef = c;
s->expn = e;
r->next = s;
r = s;
scanf("(%f,%d)",&c,&e);
i++;
}
r->next = NULL;
return head;
}
//输出多项式
void printpoly(node *head)
{
node *q=head->next;
int flag=1;
if(!q)
{
putchar('0');
printf("\n");
return ;
}
while(q)
{
if(q->coef>0&&flag!=1)
putchar('+');
if(q->coef!=1&&q->coef!=-1)
{
printf("%.0f",q->coef);
if(q->expn ==1)
putchar('X');
else if(q->expn)
printf("X^%d",q->expn);
}
else
{
if(q->coef==1)
{
if(!q->expn)
{
putchar('1');
}
else if(q->expn==1)
putchar('X');
else
printf("X^%d",q->expn);
}
if(q->coef==-1)
{
if(!q->expn)
{
printf("-1");
}
else if(q->expn==1)
printf("-X");
else
printf("-X^%d",q->expn);
}
}
q=q->next;
flag++;
}
printf("\n");
}
int main()
{
node *a;
int d;
a=(node *)malloc(sizeof(node));
a->next=NULL;
printf("请输入多项式的项数:\n");
scanf("%d",&d);
a=createpoly(d);
printpoly(a);
} */
#include<stdio.h>
#include<stdlib.h>
typedef struct Polynomial
{
int coef; //系数
int expn; //指数
struct Polynomial *next;;
}*polyn,Polynomial;
//创建多项式
polyn creatpoly()
{
Polynomial *H,*rear,*s;
int c,e; //c作为系数
int m;
int i=0;
H=(Polynomial *)malloc(sizeof(Polynomial));
rear=H;
// printf("个数：");
scanf("%d ",&m);
scanf("(%d,%d) ",&c,&e);
while(i<m)
{
s=(Polynomial *)malloc(sizeof(Polynomial));
s->coef = c;
s->expn = e;
rear->next=s;
rear = s;
scanf("(%d,%d) ",&c,&e);
i++;
}
rear->next=NULL;
return H;
}
void printpolyn(polyn P) //输出
{
polyn q=P->next;
int flag=1;
if(!q)
{
putchar('0');
printf("\n");
return;
}
while(q)
{
if(q->coef==0) q=q->next;
if(q->coef>0&&flag!=1) putchar('+');
if(q->coef!=1&&q->coef!=-1)
{
printf("%d",q->coef);
if(q->expn==1) putchar('X');
else if(q->expn) printf("X^%d",q->expn);
}
else
{
if(q->coef==1)
{
if(!q->expn) putchar('1');
else if(q->expn==1) putchar('X');
else printf("X^%d",q->expn);
}
if(q->coef==-1)
{
if(!q->expn) printf("-1");
else if(q->expn==1) printf("-X");
else printf("-X^%d",q->expn);
}
}
q=q->next;
flag++;
}
printf("\n");
}/*
polyn AddPolyn(polyn pa,polyn pb) //多项式相加
{
//Polyn *pa,*pb;
Polynomial *H,*pc,*qc;
polyn qa=pa->next;
polyn qb=pb->next;
pc=(Polynomial *)malloc(sizeof(Polynomial));
pc->next=NULL;
H=pc;
while(qa!=NULL&&qb!=NULL)
{
qc=(Polynomial *)malloc(sizeof(Polynomial));
if(qa->expn < qb->expn)
{
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;
}
else if(qa->expn==qb->expn)
{
qc->coef=qa->coef+qb->coef;
qc->expn=qa->expn;
qa=qa->next;
qb=qb->next;
}
else
{
qc->coef=qb->coef;
qc->expn=qb->expn;
qb=qb->next;
}
if(qc->coef!=0)
{
qc->next=pc->next;
pc->next=qc;
pc=qc;
}
else free(qc);
}
while(qa!=NULL)
{
qc=(Polynomial *)malloc(sizeof(Polynomial));
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;
qc->next=pc->next;
pc->next=qc;
pc=qc;
}
while(qb!=NULL)
{
qc=(Polynomial *)malloc(sizeof(Polynomial));
qc->coef=qb->coef;
qc->expn=qb->expn;
qb=qb->next;
qc->next=pc->next;
pc->next=qc;
pc=qc;
}
return H;
}*/
polyn AddPolyn(polyn pa,polyn pb) //相加
{
polyn qa=pa->next;
polyn qb=pb->next;
polyn dc,qc,pc;
pc=(Polynomial *)malloc(sizeof(Polynomial));
pc->next=NULL;
while(qa&&qb)
{
qc=(Polynomial *)malloc(sizeof(Polynomial));
if(qa->expn<qb->expn)
{
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;
}
else if(qa->expn>qb->expn)
{
qc->coef=qb->coef;
qc->expn=qb->expn;
qb=qb->next;
}
else
{
qc->coef=qa->coef+qb->coef;
qc->expn=qa->expn;
qa=qa->next;
qb=qb->next;
}
qc->next=NULL;
if(qc->coef!=0)
{
if(pc->next==NULL)
{
dc=pc->next=qc;
}
else
{
dc=dc->next=qc;
}
}
else
{
free(qc);
}
}
if(qa)
{
dc->next=qa;
}
else
{
dc->next=qb;
}
return pc;
// printpolyn(pc);
}
polyn SubtractPolyn(polyn pa,polyn pb) //相减
{
polyn h=pb;
polyn p=pb->next;
polyn pd;
while(p)
{
p->coef*=-1;
p=p->next;
}
pd=AddPolyn(pa,h);
for(p=h->next;p;p=p->next)
{
p->coef*=-1;
}
return pd;
printpolyn(pd);
}
/*
polyn Product_Polyn(polyn pa,polyn pb) //相乘
{
polyn qa=pa->next;
polyn qb;
polyn pc;
polyn s;
polyn t;
polyn ptemp;
pc=(Polynomial *)malloc(sizeof(Polynomial));
pc->next=NULL;
while(qa){
qb=pb->next;
while(qb){
s=(Polynomial *)malloc(sizeof(Polynomial));
s->next=NULL;
s->coef=qa->coef*qb->coef;
s->expn=qa->expn+qb->expn;
if(pc->next==NULL){
pc->next=t=s;
}
else{
for(ptemp=pc;ptemp->next;ptemp=ptemp->next){
if(s->expn==ptemp->next->expn){
break;
}
}
if(ptemp->next){
ptemp->next->coef+=s->coef;
free(s);
}
else{
for(ptemp=pc;ptemp->next;ptemp=ptemp->next){
if(s->expn<ptemp->next->expn){
break;
}
}
s->next=ptemp->next;
ptemp->next=s;
}
}
qb=qb->next;
}
qa=qa->next;
}
//return pc;
printpolyn(pc);
}
*/
main()
{
Polynomial *PA=NULL;
Polynomial *PB=NULL;
Polynomial *PC=NULL;
// printf("创建A\n");
PA=creatpoly();
// printpolyn(PA);
// printf("创建B\n");
PB=creatpoly();
//PC=Product_Polyn(PA,PB);
// printpolyn(PB);
PC=SubtractPolyn(PA,PB);
//printf("输出C\n");
printpolyn(PC);
}
| [
"[email protected]"
] | |
937b1533f316af264261c256df0696cb87f2b7e9 | 814b93aa2e8849cdb1ca7760cb356c3ede6f0970 | /Game/Boundary.cpp | 6f20e12b2c96d4f3229dd486e92aa6a221efd39f | [] | no_license | MatteoBre/graphics_engine_game | 2bf50a2475de32a16a491cf47513505253d6dff2 | e6f00363a88bbba008bff0b48fa186baf59abcf2 | refs/heads/main | 2023-02-09T16:31:46.931929 | 2021-01-05T21:39:58 | 2021-01-05T21:39:58 | 314,320,589 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22 | cpp | #include "Boundary.h"
| [
"[email protected]"
] | |
9125673a255d1440c6bb70b70b7a670f3285826f | ea1f258d5544148cf69d172bf2996c9d06b7c70c | /tb_supply.hpp | 4f9654b5a67f2139e75dd94957f38dc3d509266b | [] | no_license | TacBF/tb_rhs_edge.mountains_acr | a7e6c5452fc2653eede8eea9b25fd5e173180162 | 5adc15fefb1a8927c4d1467c9f90354159b915ea | refs/heads/master | 2021-01-19T20:31:18.683042 | 2017-04-17T14:39:22 | 2017-04-17T14:39:22 | 88,517,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,770 | hpp | class TacBF
{
class Supply
{
// Generates cargo IDs (More effecient broadcasting for these items + their ammo)
staticWeapons[] = {"RDS_M2StaticMG_MiniTripod_FIA", "RDS_M2StaticMG_FIA", "RDS_KORD_high_CSAT", "RDS_KORD_CSAT", "RDS_DSHKM_CSAT", "RDS_DSHkM_Mini_TriPod_CSAT", "RDS_M252_FIA", "RDS_2b14_82mm_CSAT", "RDS_TOW_TriPod_FIA", "RDS_Metis_CSAT", "RDS_SPG9_CSAT", "RDS_D30_CSAT", "RDS_ZU23_CSAT", "RDS_M119_FIA"};
class CargoCollections
{
// West Statics
class statics_westLight {
transportClear = 1;
cargo[] = {
{"TB_Box_West_Mines_F", 2, 0},
{"ICE_emptySandbagsTimberStack", 10,0}
};
};
class statics_west {
transportClear = 1;
cargo[] = {
{"TB_Box_West_Mines_F", 4, 0},
{"ICE_emptySandbagsCrate_supply", 3,0}
};
};
class statics_westHeavy {
transportClear = 1;
cargo[] = {
{"TB_Box_West_Mines_F", 6, 0},
{"ICE_emptySandbagsCrate_supply", 6,0}
};
};
// East Statics
class statics_eastLight {
transportClear = 1;
cargo[] = {
{"TB_Box_East_Mines_F", 2, 0},
{"ICE_emptySandbagsTimberStack", 10,0}
};
};
class statics_east {
transportClear = 1;
cargo[] = {
{"TB_Box_East_Mines_F", 4, 0},
{"ICE_emptySandbagsCrate_supply", 3,0}
};
};
class statics_eastHeavy {
transportClear = 1;
cargo[] = {
{"RDS_2b14_82mm_CSAT", 1, 3},
{"TB_Box_East_Mines_F", 6, 0},
{"ICE_emptySandbagsCrate_supply", 6,0}
};
};
// RES Statics
class statics_resLight {
transportClear = 1;
cargo[] = {
{"TB_Box_East_Mines_F", 2, 0},
{"ICE_emptySandbagsTimberStack", 10,0}
};
};
class statics_res {
transportClear = 1;
cargo[] = {
{"RDS_SPG9_CSAT", 1, 2},
{"TB_Box_East_Mines_F", 4, 0},
{"ICE_emptySandbagsCrate_supply", 3,0}
};
};
class statics_resHeavy {
transportClear = 1;
cargo[] = {
{"RDS_2b14_82mm_CSAT", 1, 3},
{"TB_Box_East_Mines_F", 6, 0},
{"ICE_emptySandbagsCrate_supply", 6,0}
};
};
//FO Statics
class rds_westFO {
transportClear = 1;
cargo[] = {
{"TB_Box_West_Mines_F", 1, 0},
{"ICE_emptySandbagsCrate_supply", 2,0}
};
};
class rds_eastFO {
transportClear = 1;
cargo[] = {
{"TB_Box_East_Mines_F", 1, 0},
{"ICE_emptySandbagsCrate_supply", 2,0}
};
};
};
class Containers
{
class ICE_ForwardOutpost_container_WestMG
{
crateCollection = "rds_westFO";
crateMass = 1750;
};
class ICE_ForwardOutpost_container_EastMG
{
crateCollection = "rds_eastFO";
crateMass = 1750;
};
};
};
}; | [
"[email protected]"
] | |
58e77f4651721815eb2d4565916e9a28ecdcf039 | d852ae6c0eebd3642613e3a27541de266b596e5a | /hl2sdk/Structs/keyvalues.h | 4ddf851498c3649918d76348dc3c65189dda45a2 | [] | no_license | METAMONDESU/l4d2Simple | e2fae38d54f20545d7e452eb2330e20d8a0241d9 | 9e002c787365f71a15d56ee11b1b2f71aa3c51ce | refs/heads/master | 2023-07-16T21:04:46.414787 | 2018-02-14T08:51:37 | 2018-02-14T08:51:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 626 | h | #pragma once
#include <Windows.h>
class KeyValues
{
public:
enum MergeKeyValuesOp_t
{
MERGE_KV_ALL,
MERGE_KV_UPDATE,
MERGE_KV_DELETE,
MERGE_KV_BORROW
};
private:
DWORD m_iKeyName : 24;
DWORD m_iKeyNameCaseSensitive1 : 8;
char* m_sValue;
wchar_t* m_wsValue;
union
{
int m_iValue;
float m_flValue;
PVOID m_pValue;
BYTE m_Color[4];
};
char m_iDataType;
char m_bHasEscapeSequences;
WORD m_iKeyNameCaseSensitive2;
KeyValues* m_pPeer;
KeyValues* m_pSub;
KeyValues* m_pChain;
DWORD pad0; // cba to figure out if it's at the bottom of the class or somewhere else. it works, i don't care.
};
| [
"[email protected]"
] | |
b8e19a8b5f8a986b200f0d11b8257683195c7f0e | 545527678641223a21ac1522d3dd9cb6a1b01a5a | /Handin2/src/app/discrete/state/simulation.cpp | 3001e0d8ac41e311e8c02765d9ddf211e4b90a0a | [] | no_license | kpagels/TIERTSHandin2 | 105bcc1b481e0c97811955b358f515fe249e5b2a | 314e4f20d7719107320aa0b8ffa8283e1a996e19 | refs/heads/master | 2021-07-16T07:00:13.246326 | 2017-10-15T20:10:25 | 2017-10-15T20:10:25 | 106,560,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 838 | cpp | #include "systemx/os/iostream.hpp"
#include "systemx/app/discrete/isystem.hpp"
#include "systemx/app/discrete/istatemachine.hpp"
#include "systemx/app/discrete/state/simulation.hpp"
#include "systemx/app/discrete/state/realtimeexecution.hpp"
namespace systemx {
namespace app {
namespace state {
namespace base {
void SimulationBase::EnterState(ISystem* system, IStateMachine* statemachine) {
system->logger() << "EnterState: Simulation" << os::endl;
system->continues.set_mode_sim();
}
void SimulationBase::ExitState(ISystem* system, IStateMachine* statemachine) {
system->logger() << "ExitState: Simulation" << os::endl;
}
void SimulationBase::RunRealTime(ISystem* system, IStateMachine* statemachine) {
statemachine->ChangeState(RealTimeExecution::Instance());
}
}
}
}
}
| [
"[email protected]"
] | |
f829169f8a2a3f06991185bc41c351fb98989fe2 | 050e2bb9bfbd7d6874f0f7a4465419300cfa74fd | /src/stdendian.h | 847db07a6eb93755315548407f37e924f0b03491 | [
"MIT"
] | permissive | jdart1/Fathom | 0487161d1d3159d3b070860b84b574034b4dd181 | aeb9d696c230335a0ebafa36a931427d4a2698ad | refs/heads/master | 2023-08-18T18:47:31.160628 | 2023-08-13T15:23:22 | 2023-08-13T15:23:22 | 52,562,033 | 50 | 35 | MIT | 2022-11-26T17:43:13 | 2016-02-25T22:40:56 | C | UTF-8 | C++ | false | false | 8,943 | h | #ifndef _STDENDIAN_H_
#define _STDENDIAN_H_
/* from https://gist.github.com/michaeljclark/3b4fd912f6fa8bb598b3 */
/* modified to use functions not macros for bswap */
/* and added a fix for Cygwin */
/*
* stdendian.h
*
* This header defines the following endian macros as defined here:
* http://austingroupbugs.net/view.php?id=162
*
* BYTE_ORDER this macro shall have a value equal to one
* of the *_ENDIAN macros in this header.
* LITTLE_ENDIAN if BYTE_ORDER == LITTLE_ENDIAN, the host
* byte order is from least significant to
* most significant.
* BIG_ENDIAN if BYTE_ORDER == BIG_ENDIAN, the host byte
* order is from most significant to least
* significant.
*
* The following are defined as macros:
*
* uint16_t bswap16(uint16_t x);
* uint32_t bswap32(uint32_t x);
* uint64_t bswap64(uint64_t x);
* uint16_t htobe16(uint16_t x);
* uint16_t htole16(uint16_t x);
* uint16_t be16toh(uint16_t x);
* uint16_t le16toh(uint16_t x);
*
* uint32_t htobe32(uint32_t x);
* uint32_t htole32(uint32_t x);
* uint32_t be32toh(uint32_t x);
* uint32_t le32toh(uint32_t x);
*
* uint64_t htobe64(uint64_t x);
* uint64_t htole64(uint64_t x);
* uint64_t be64toh(uint64_t x);
* uint64_t le64toh(uint64_t x);
*
* The header defines the following macro for OpenCL compatibility
* https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/preprocessorDirectives.html
*
* __ENDIAN_LITTLE__ if BYTE_ORDER == LITTLE_ENDIAN then this
* macro is present for OpenCL compatibility
*
* The implementation provides a uniform interface to endian macros using only
* system headers on recent Linux, Darwin, FreeBSD, Solaris and Windows systems.
*
* This approach is intended to avoid the need for preflight configure scripts.
* An alternative approach would be to test compiler CPU architecture marcros.
*
* This header has had *limited* testing on recent C11/C++11 compilers and is
* based on the austin bug tracker interface, manpages, and headers present in
* Linux, FreeBSD, Windows, Solaris and Darwin.
*
* The header uses __builtin_bswapXX intrinsic with GCC/Clang (__GNUC__) on
* platforms that do not provide bswap16, bswap32, bswap64 (Darwin)
*
* Public Domain.
*/
/* requires C11 or C++11 */
#if defined (__cplusplus)
#include <cstdint>
#elif !defined (__OPENCL_VERSION__)
#include <stdint.h>
#endif
/* Linux / GLIBC */
#if defined(__linux__) || defined(__GLIBC__) || defined(__CYGWIN__)
#include <endian.h>
#include <byteswap.h>
#define __ENDIAN_DEFINED 1
#define __BSWAP_DEFINED 1
#define __HOSTSWAP_DEFINED 1
// NDK defines _BYTE_ORDER etc
#ifndef _BYTE_ORDER
#define _BYTE_ORDER __BYTE_ORDER
#define _LITTLE_ENDIAN __LITTLE_ENDIAN
#define _BIG_ENDIAN __BIG_ENDIAN
#endif
#define bswap16(x) bswap_16(x)
#define bswap32(x) bswap_32(x)
#define bswap64(x) bswap_64(x)
#endif /* __linux__ || __GLIBC__ */
/* BSD */
#if defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__DragonFly__) || defined(__OpenBSD__)
#include <sys/endian.h>
#define __ENDIAN_DEFINED 1
#define __BSWAP_DEFINED 1
#define __HOSTSWAP_DEFINED 1
#endif /* BSD */
/* Solaris */
#if defined (sun)
#include <sys/isa_defs.h>
/* sun headers don't set a value for _LITTLE_ENDIAN or _BIG_ENDIAN */
#if defined(_LITTLE_ENDIAN)
#undef _LITTLE_ENDIAN
#define _LITTLE_ENDIAN 1234
#define _BIG_ENDIAN 4321
#define _BYTE_ORDER _LITTLE_ENDIAN
#elif defined(_BIG_ENDIAN)
#undef _BIG_ENDIAN
#define _LITTLE_ENDIAN 1234
#define _BIG_ENDIAN 4321
#define _BYTE_ORDER _BIG_ENDIAN
#endif
#define __ENDIAN_DEFINED 1
#endif /* sun */
/* Windows (also Emscripten) */
#if defined(_WIN32) || defined(_MSC_VER) || defined(__EMSCRIPTEN__)
/* assumes all Microsoft targets are little endian. */
/* Emscripten (emcc) also currently assumes little endian. */
#define _LITTLE_ENDIAN 1234
#define _BIG_ENDIAN 4321
#define _BYTE_ORDER _LITTLE_ENDIAN
#define __ENDIAN_DEFINED 1
#endif /* _MSC_VER */
/* OS X */
#if defined(__APPLE__)
#include <machine/endian.h>
#define _BYTE_ORDER BYTE_ORDER
#define _LITTLE_ENDIAN LITTLE_ENDIAN
#define _BIG_ENDIAN BIG_ENDIAN
#define __ENDIAN_DEFINED 1
#endif /* __APPLE__ */
/* OpenCL */
#if defined (__OPENCL_VERSION__)
#define _LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#if defined (__ENDIAN_LITTLE__)
#define _BYTE_ORDER _LITTLE_ENDIAN
#else
#define _BYTE_ORDER _BIG_ENDIAN
#endif
#define bswap16(x) as_ushort(as_uchar2(ushort(x)).s1s0)
#define bswap32(x) as_uint(as_uchar4(uint(x)).s3s2s1s0)
#define bswap64(x) as_ulong(as_uchar8(ulong(x)).s7s6s5s4s3s2s1s0)
#define __ENDIAN_DEFINED 1
#define __BSWAP_DEFINED 1
#endif
/* Unknown */
#if !__ENDIAN_DEFINED
#error Could not determine CPU byte order
#endif
/* POSIX - http://austingroupbugs.net/view.php?id=162 */
#ifndef BYTE_ORDER
#define BYTE_ORDER _BYTE_ORDER
#endif
#ifndef LITTLE_ENDIAN
#define LITTLE_ENDIAN _LITTLE_ENDIAN
#endif
#ifndef BIG_ENDIAN
#define BIG_ENDIAN _BIG_ENDIAN
#endif
/* OpenCL compatibility - define __ENDIAN_LITTLE__ on little endian systems */
#if _BYTE_ORDER == _LITTLE_ENDIAN
#if !defined (__ENDIAN_LITTLE__)
#define __ENDIAN_LITTLE__ 1
#endif
#endif
/* Byte swap macros */
#if !__BSWAP_DEFINED
#ifndef bswap16
/* handle missing __builtin_bswap16 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624 */
#if defined __GNUC__
#define bswap16(x) __builtin_bswap16(x)
#else
inline uint16_t bswap16(uint16_t x) {
return (uint16_t)((((uint16_t) (x) & 0xff00) >> 8) | \
(((uint16_t) (x) & 0x00ff) << 8));
}
#endif
#endif
#ifndef bswap32
#if defined __GNUC__
#define bswap32(x) __builtin_bswap32(x)
#else
inline uint32_t bswap32(uint32_t x) {
return (( x & 0xff000000) >> 24) | \
(( x & 0x00ff0000) >> 8) | \
(( x & 0x0000ff00) << 8) | \
(( x & 0x000000ff) << 24);
}
#endif
#endif
#ifndef bswap64
#if defined __GNUC__
#define bswap64(x) __builtin_bswap64(x)
#else
inline uint64_t bswap64(uint64_t x) {
return (( x & 0xff00000000000000ull) >> 56) | \
(( x & 0x00ff000000000000ull) >> 40) | \
(( x & 0x0000ff0000000000ull) >> 24) | \
(( x & 0x000000ff00000000ull) >> 8) | \
(( x & 0x00000000ff000000ull) << 8) | \
(( x & 0x0000000000ff0000ull) << 24) | \
(( x & 0x000000000000ff00ull) << 40) | \
(( x & 0x00000000000000ffull) << 56);
}
#endif
#endif
#endif
/* Host swap macros */
#ifndef __HOSTSWAP_DEFINED
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define htobe16(x) bswap16((x))
#define htole16(x) ((uint16_t)(x))
#define be16toh(x) bswap16((x))
#define le16toh(x) ((uint16_t)(x))
#define htobe32(x) bswap32((x))
#define htole32(x) ((uint32_t((x))
#define be32toh(x) bswap32((x))
#define le32toh(x) ((uint32_t)(x))
#define htobe64(x) bswap64((x))
#define htole64(x) ((uint64_t)(x))
#define be64toh(x) bswap64((x))
#define le64toh(x) ((uint64_t)(x))
#elif __BYTE_ORDER == __BIG_ENDIAN
#define htobe16(x) ((uint16_t)(x))
#define htole16(x) bswap16((x))
#define be16toh(x) ((uint16_t)(x))
#define le16toh(x) bswap16((x))
#define htobe32(x) ((uint32_t)(x))
#define htole32(x) bswap32((x))
#define be32toh(x) ((uint32_t)(x))
#define le64toh(x) bswap64((x))
#define htobe64(x) ((uint64_t)(x))
#define htole64(x) bswap64((x))
#define be64toh(x) ((uint64_t)(x))
#define le32toh(x) bswap32((x))
#endif
#endif
/*
#include <stdio.h>
#include <stdendian.h>
int main()
{
#if BYTE_ORDER == LITTLE_ENDIAN
printf("little endian\n");
#endif
#if BYTE_ORDER == BIG_ENDIAN
printf("big endian\n");
#endif
printf("bswap16(%04x) %04x\n", 0xf0e0, bswap16(0xf0e0));
printf("htobe16(%04x) %04x\n", 0xf0e0, htobe16(0xf0e0));
printf("htole16(%04x) %04x\n", 0xf0e0, htole16(0xf0e0));
printf("bswap32(%08x) %08x\n", 0xf0e0d0c0, bswap32(0xf0e0d0c0));
printf("htobe32(%08x) %08x\n", 0xf0e0d0c0, htobe32(0xf0e0d0c0));
printf("htole32(%08x) %08x\n", 0xf0e0d0c0, htole32(0xf0e0d0c0));
printf("bswap64(%016llx) %016llx\n", 0xf0e0d0c0b0a09080ULL, bswap64(0xf0e0d0c0b0a09080ULL));
printf("htobe64(%016llx) %016llx\n", 0xf0e0d0c0b0a09080ULL, htobe64(0xf0e0d0c0b0a09080ULL));
printf("htole64(%016llx) %016llx\n", 0xf0e0d0c0b0a09080ULL, htole64(0xf0e0d0c0b0a09080ULL));
}
*/
#endif
| [
"[email protected]"
] | |
f09a87090db7d8a06366d68405a00ee5d37d7b04 | 4de2e83c40d3a01065cde56fed757e1f5ea55fb5 | /Final Project/Final Project/ERemployee.h | b396bf466da95ffb03301bc621edc1ae81ec267e | [] | no_license | j-tone/FinalProject273 | 4f2c3ad1721a98951e9edbc49fca6e5a3d6cc445 | f4f285c648468fec8be55291267c8eb1f8d7f4a9 | refs/heads/master | 2016-09-06T20:01:35.723154 | 2014-12-05T02:25:44 | 2014-12-05T02:25:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,394 | h | #ifndef EREMPLOYEE_H_
#define EREMPLOYEE_H_
#include "Patient.h"
#include <ctime>
#include <cstdlib>
using namespace std;
class ERemployee{
protected:
bool busy;
bool worked;
Patient* tendingTo;
int timeRemaining;
public:
ERemployee(){
busy = false;
}
void work(Records y, int time){
timeRemaining--;
worked = true;
if (timeRemaining == 0){
DoneTreating(y, time);
}
return;
}
virtual void start(Patient *x){}
void DoneTreating(Records y, int time){
tendingTo->gettimeReleased = time;
y.Add(*tendingTo);
busy = false;
return;
}
int PatientSeverity(){
return tendingTo->getENTEREDseverity();
}
void Reset(){
worked = false;
return;
}
bool Busy(){
return busy;
}
Patient* GetPatient(){
return tendingTo;
}
};
class Doctor: public ERemployee{
public:
Doctor() :ERemployee(){}
void start(Patient *x){
busy = true;
tendingTo = x;
timeRemaining = (rand() % 20) + 1;
}
int getTimeRemaining(){
return timeRemaining;
}
void Relieve(){
busy = false;
}
};
class Nurse : public ERemployee{
public:
Nurse() :ERemployee(){}
void start(Patient *x){
busy = true;
tendingTo = x;
timeRemaining = (rand() % 10) + 1;
}
void InheritTime(int timeR1){
if (timeR1 < 10){
timeRemaining = timeR1;
}
else{
timeRemaining = 10;
}
}
};
#endif | [
"[email protected]"
] | |
77aa0f5f3d08caf037c17eb6d3dc43318c75531c | d3deae1e568e865326a74228323d92a7415bcb20 | /chrome/browser/chromeos/arc/tracing/arc_tracing_graphics_model.cc | 4375f33839b38039e82866e7a5002008cf24959c | [
"BSD-3-Clause"
] | permissive | bigbang009/chromium | 74826aba346f93e2f3cb7bdb087354d98c374c2e | ac67926cabbbf7e414b3fc8ce83ea2ebbd59d8a2 | refs/heads/master | 2023-01-13T08:14:22.715227 | 2019-04-11T16:40:18 | 2019-04-11T16:40:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 46,562 | cc | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/chromeos/arc/tracing/arc_tracing_graphics_model.h"
#include <algorithm>
#include "base/bind.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/no_destructor.h"
#include "base/time/time.h"
#include "base/trace_event/common/trace_event_common.h"
#include "chrome/browser/chromeos/arc/tracing/arc_graphics_jank_detector.h"
#include "chrome/browser/chromeos/arc/tracing/arc_tracing_event.h"
#include "chrome/browser/chromeos/arc/tracing/arc_tracing_event_matcher.h"
#include "chrome/browser/chromeos/arc/tracing/arc_tracing_model.h"
#include "components/arc/arc_util.h"
namespace arc {
namespace {
using BufferEvent = ArcTracingGraphicsModel::BufferEvent;
using BufferEvents = ArcTracingGraphicsModel::BufferEvents;
using BufferEventType = ArcTracingGraphicsModel::BufferEventType;
constexpr char kUnknownActivity[] = "unknown";
constexpr char kArgumentAppId[] = "app_id";
constexpr char kArgumentBufferId[] = "buffer_id";
constexpr char kArgumentPutOffset[] = "put_offset";
constexpr char kKeyActivity[] = "activity";
constexpr char kKeyAndroid[] = "android";
constexpr char kKeyBuffers[] = "buffers";
constexpr char kKeyChrome[] = "chrome";
constexpr char kKeyCpu[] = "cpu";
constexpr char kKeyDuration[] = "duration";
constexpr char kKeyGlobalEvents[] = "global_events";
constexpr char kKeyViews[] = "views";
constexpr char kKeyTaskId[] = "task_id";
constexpr char kAcquireBufferQuery[] =
"android:onMessageReceived/android:handleMessageInvalidate/"
"android:latchBuffer/android:updateTexImage/android:acquireBuffer";
// Android PI+
constexpr char kReleaseBufferQueryP[] =
"android:onMessageReceived/android:handleMessageRefresh/"
"android:postComposition/android:releaseBuffer";
// Android NYC
constexpr char kReleaseBufferQueryN[] =
"android:onMessageReceived/android:handleMessageRefresh/"
"android:releaseBuffer";
constexpr char kDequeueBufferQuery[] = "android:dequeueBuffer";
constexpr char kQueueBufferQuery[] = "android:queueBuffer";
constexpr char kBarrierOrderingSubQuery[] =
"gpu:CommandBufferProxyImpl::OrderingBarrier";
constexpr char kBufferInUseQuery[] = "exo:BufferInUse";
constexpr char kHandleMessageRefreshQuery[] =
"android:onMessageReceived/android:handleMessageRefresh";
constexpr char kHandleMessageInvalidateQuery[] =
"android:onMessageReceived/android:handleMessageInvalidate";
constexpr char kChromeTopEventsQuery[] =
"viz,benchmark:Graphics.Pipeline.DrawAndSwap";
constexpr char kVsyncQuery0[] = "android:HW_VSYNC_0|0";
constexpr char kVsyncQuery1[] = "android:HW_VSYNC_0|1";
constexpr char kBarrierFlushMatcher[] = "gpu:CommandBufferStub::OnAsyncFlush";
constexpr char kExoSurfaceAttachMatcher[] = "exo:Surface::Attach";
constexpr char kExoBufferProduceResourceMatcher[] =
"exo:Buffer::ProduceTransferableResource";
constexpr char kExoBufferReleaseContentsMatcher[] =
"exo:Buffer::ReleaseContents";
constexpr ssize_t kInvalidBufferIndex = -1;
// Helper factory class that produces graphic buffer events from the giving
// |ArcTracingEvent| generic events. Each |ArcTracingEvent| may produce graphics
// event |ArcTracingGraphicsModel::BufferEvent| on start or/and on finish of the
// event |ArcTracingEvent|. This is organized in form of map
// |ArcTracingEventMatcher| to the pair of |BufferEventType| which indicates
// what to generate on start and on finish of the event.
class BufferGraphicsEventMapper {
public:
struct MappingRule {
MappingRule(BufferEventType map_start, BufferEventType map_finish)
: map_start(map_start), map_finish(map_finish) {}
BufferEventType map_start;
BufferEventType map_finish;
};
using MappingRules = std::vector<
std::pair<std::unique_ptr<ArcTracingEventMatcher>, MappingRule>>;
BufferGraphicsEventMapper() {
// exo rules
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kExoSurfaceAttachMatcher),
MappingRule(BufferEventType::kExoSurfaceAttach,
BufferEventType::kNone)));
rules_.emplace_back(
std::make_pair(std::make_unique<ArcTracingEventMatcher>(
kExoBufferProduceResourceMatcher),
MappingRule(BufferEventType::kExoProduceResource,
BufferEventType::kNone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
kExoBufferReleaseContentsMatcher),
MappingRule(BufferEventType::kNone, BufferEventType::kExoReleased)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>("exo:BufferInUse(step=bound)"),
MappingRule(BufferEventType::kExoBound, BufferEventType::kNone)));
rules_.emplace_back(
std::make_pair(std::make_unique<ArcTracingEventMatcher>(
"exo:BufferInUse(step=pending_query)"),
MappingRule(BufferEventType::kExoPendingQuery,
BufferEventType::kNone)));
// gpu rules
rules_.emplace_back(
std::make_pair(std::make_unique<ArcTracingEventMatcher>(
"gpu:CommandBufferProxyImpl::OrderingBarrier"),
MappingRule(BufferEventType::kChromeBarrierOrder,
BufferEventType::kNone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kBarrierFlushMatcher),
MappingRule(BufferEventType::kNone,
BufferEventType::kChromeBarrierFlush)));
// android rules
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kDequeueBufferQuery),
MappingRule(BufferEventType::kBufferQueueDequeueStart,
BufferEventType::kBufferQueueDequeueDone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kQueueBufferQuery),
MappingRule(BufferEventType::kBufferQueueQueueStart,
BufferEventType::kBufferQueueQueueDone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>("android:acquireBuffer"),
MappingRule(BufferEventType::kBufferQueueAcquire,
BufferEventType::kNone)));
rules_.push_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>("android:releaseBuffer"),
MappingRule(BufferEventType::kNone,
BufferEventType::kBufferQueueReleased)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
"android:handleMessageInvalidate"),
MappingRule(BufferEventType::kSurfaceFlingerInvalidationStart,
BufferEventType::kSurfaceFlingerInvalidationDone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
"android:handleMessageRefresh"),
MappingRule(BufferEventType::kSurfaceFlingerCompositionStart,
BufferEventType::kSurfaceFlingerCompositionDone)));
rules_.push_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kVsyncQuery0),
MappingRule(BufferEventType::kVsync, BufferEventType::kNone)));
rules_.push_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(kVsyncQuery1),
MappingRule(BufferEventType::kVsync, BufferEventType::kNone)));
// viz,benchmark rules
auto matcher = std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap");
matcher->SetPhase(TRACE_EVENT_PHASE_ASYNC_BEGIN);
rules_.emplace_back(std::make_pair(
std::move(matcher),
MappingRule(BufferEventType::kChromeOSDraw, BufferEventType::kNone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap(step=Draw)"),
MappingRule(BufferEventType::kNone, BufferEventType::kNone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap(step=Swap)"),
MappingRule(BufferEventType::kChromeOSSwap, BufferEventType::kNone)));
rules_.emplace_back(std::make_pair(
std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap(step=WaitForAck)"),
MappingRule(BufferEventType::kChromeOSWaitForAck,
BufferEventType::kNone)));
rules_.emplace_back(
std::make_pair(std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap(step="
"WaitForPresentation)"),
MappingRule(BufferEventType::kChromeOSPresentationDone,
BufferEventType::kNone)));
matcher = std::make_unique<ArcTracingEventMatcher>(
"viz,benchmark:Graphics.Pipeline.DrawAndSwap");
matcher->SetPhase(TRACE_EVENT_PHASE_ASYNC_END);
rules_.emplace_back(std::make_pair(
std::move(matcher), MappingRule(BufferEventType::kNone,
BufferEventType::kChromeOSSwapDone)));
}
~BufferGraphicsEventMapper() = default;
void Produce(const ArcTracingEvent& event,
ArcTracingGraphicsModel::BufferEvents* collector) const {
for (const auto& rule : rules_) {
if (!rule.first->Match(event))
continue;
if (rule.second.map_start != BufferEventType::kNone) {
collector->push_back(ArcTracingGraphicsModel::BufferEvent(
rule.second.map_start, event.GetTimestamp()));
}
if (rule.second.map_finish != BufferEventType::kNone) {
collector->push_back(ArcTracingGraphicsModel::BufferEvent(
rule.second.map_finish, event.GetEndTimestamp()));
}
return;
}
LOG(ERROR) << "Unsupported event: " << event.ToString();
}
private:
MappingRules rules_;
DISALLOW_COPY_AND_ASSIGN(BufferGraphicsEventMapper);
};
BufferGraphicsEventMapper& GetEventMapper() {
static base::NoDestructor<BufferGraphicsEventMapper> instance;
return *instance;
}
// Maps particular buffer to its events.
using BufferToEvents =
std::map<std::string, ArcTracingGraphicsModel::BufferEvents>;
bool SortByTimestampPred(const ArcTracingGraphicsModel::BufferEvent& a,
const ArcTracingGraphicsModel::BufferEvent& b) {
return a.timestamp < b.timestamp;
}
void SortBufferEventsByTimestamp(BufferEvents* events) {
std::sort(events->begin(), events->end(), SortByTimestampPred);
}
// Extracts buffer id from the surface flinger event. For example:
// android|releaseBuffer
// android|com.android.vending/com.android.vending.AssetBrowserActivity#0: 2
// Buffer id appears as a child event where name if the combination of the
// current view of the Activity, its index and the number of buffer starting
// from 0. This helps to exactly identify the particular buffer in context of
// Android. Buffer id for this example is
// "com.android.vending/com.android.vending.AssetBrowserActivity#0: 2"
bool ExtractBufferIdFromSurfaceFlingerEvent(const ArcTracingEvent& event,
std::string* id) {
for (const auto& child : event.children()) {
if (child->GetPhase() != TRACE_EVENT_PHASE_COMPLETE)
continue;
const std::string& name = child->GetName();
size_t index = name.find(": ");
if (index == std::string::npos)
continue;
index += 2;
if (index >= name.length())
continue;
bool all_digits = true;
while (index < name.length() && all_digits) {
all_digits &= (name[index] >= '0' && name[index] <= '9');
++index;
}
if (!all_digits)
continue;
*id = name;
return true;
}
return false;
}
// Extracts the activity name from the buffer id by discarding the buffer id
// and view index. For example, activity name for buffer id
// "com.android.vending/com.android.vending.AssetBrowserActivity#0: 2"
// is "com.android.vending/com.android.vending.AssetBrowserActivity".
// If the activity cannot be extracted then default |kUnknownActivity| is
// returned.
std::string GetActivityFromBufferName(const std::string& android_buffer_name) {
const size_t position = android_buffer_name.find('#');
if (position == std::string::npos)
return kUnknownActivity;
return android_buffer_name.substr(0, position);
}
// Processes surface flinger events. It selects events using |query| from the
// model. Buffer id is extracted for the each returned event and new events are
// grouped by its buffer id.
void ProcessSurfaceFlingerEvents(const ArcTracingModel& common_model,
const std::string& query,
BufferToEvents* buffer_to_events) {
const ArcTracingModel::TracingEventPtrs surface_flinger_events =
common_model.Select(query);
std::string buffer_id;
for (const ArcTracingEvent* event : surface_flinger_events) {
if (!ExtractBufferIdFromSurfaceFlingerEvent(*event, &buffer_id)) {
LOG(ERROR) << "Failed to get buffer id from surface flinger event";
continue;
}
ArcTracingGraphicsModel::BufferEvents& graphics_events =
(*buffer_to_events)[buffer_id];
GetEventMapper().Produce(*event, &graphics_events);
}
}
// Processes Android events acquireBuffer, releaseBuffer, dequeueBuffer and
// queueBuffer. It returns map buffer id to the list of sorted by timestamp
// events.
BufferToEvents GetSurfaceFlingerEvents(const ArcTracingModel& common_model) {
BufferToEvents per_buffer_surface_flinger_events;
ProcessSurfaceFlingerEvents(common_model, kAcquireBufferQuery,
&per_buffer_surface_flinger_events);
ProcessSurfaceFlingerEvents(common_model, kReleaseBufferQueryP,
&per_buffer_surface_flinger_events);
ProcessSurfaceFlingerEvents(common_model, kReleaseBufferQueryN,
&per_buffer_surface_flinger_events);
ProcessSurfaceFlingerEvents(common_model, kQueueBufferQuery,
&per_buffer_surface_flinger_events);
ProcessSurfaceFlingerEvents(common_model, kDequeueBufferQuery,
&per_buffer_surface_flinger_events);
for (auto& buffer : per_buffer_surface_flinger_events)
SortBufferEventsByTimestamp(&buffer.second);
return per_buffer_surface_flinger_events;
}
// Processes exo events Surface::Attach and Buffer::ReleaseContents. Each event
// has argument buffer_id that identifies graphics buffer on Chrome side.
// buffer_id is just row pointer to internal class. If |buffer_id_to_task_id| is
// set then it is updated to map buffer id to task id.
void ProcessChromeEvents(const ArcTracingModel& common_model,
const std::string& query,
BufferToEvents* buffer_to_events,
std::map<std::string, int>* buffer_id_to_task_id) {
const ArcTracingModel::TracingEventPtrs chrome_events =
common_model.Select(query);
for (const ArcTracingEvent* event : chrome_events) {
const std::string buffer_id = event->GetArgAsString(
kArgumentBufferId, std::string() /* default_value */);
if (buffer_id.empty()) {
LOG(ERROR) << "Failed to get buffer id from event: " << event->ToString();
continue;
}
if (buffer_id_to_task_id) {
const std::string app_id = event->GetArgAsString(
kArgumentAppId, std::string() /* default_value */);
if (app_id.empty()) {
LOG(ERROR) << "Failed to get app id from event: " << event->ToString();
continue;
}
int task_id = GetTaskIdFromWindowAppId(app_id);
if (task_id == kNoTaskId) {
LOG(ERROR) << "Failed to parse app id from event: "
<< event->ToString();
continue;
}
(*buffer_id_to_task_id)[buffer_id] = task_id;
}
ArcTracingGraphicsModel::BufferEvents& graphics_events =
(*buffer_to_events)[buffer_id];
GetEventMapper().Produce(*event, &graphics_events);
}
}
std::string RouteToSelector(const std::vector<const ArcTracingEvent*>& route) {
std::string result;
for (const ArcTracingEvent* segment : route)
result = result + "/" + segment->GetCategory() + ":" + segment->GetName();
return result;
}
void DetermineHierarchy(std::vector<const ArcTracingEvent*>* route,
const ArcTracingEvent* event,
const ArcTracingEventMatcher& matcher,
std::string* out_query) {
if (!out_query->empty())
return;
route->emplace_back(event);
if (matcher.Match(*event)) {
*out_query = RouteToSelector(*route);
} else {
for (const auto& child : event->children())
DetermineHierarchy(route, child.get(), matcher, out_query);
}
route->pop_back();
}
BufferToEvents GetChromeEvents(
const ArcTracingModel& common_model,
std::map<std::string, int>* buffer_id_to_task_id) {
// The tracing hierarchy may be easy changed any time in Chrome. This makes
// using static queries fragile and dependent of many external components. To
// provide the reliable way of requesting the needed information, let scan
// |common_model| for top level events and determine the hierarchy of
// interesting events dynamically.
const ArcTracingModel::TracingEventPtrs top_level_events =
common_model.Select("toplevel:");
std::vector<const ArcTracingEvent*> route;
std::string barrier_flush_query;
const ArcTracingEventMatcher barrier_flush_matcher(kBarrierFlushMatcher);
std::string attach_surface_query;
const ArcTracingEventMatcher attach_surface_matcher(kExoSurfaceAttachMatcher);
std::string produce_resource_query;
const ArcTracingEventMatcher produce_resource_matcher(
kExoBufferProduceResourceMatcher);
std::string release_contents_query;
const ArcTracingEventMatcher release_contents_matcher(
kExoBufferReleaseContentsMatcher);
for (const ArcTracingEvent* top_level_event : top_level_events) {
DetermineHierarchy(&route, top_level_event, barrier_flush_matcher,
&barrier_flush_query);
DetermineHierarchy(&route, top_level_event, attach_surface_matcher,
&attach_surface_query);
DetermineHierarchy(&route, top_level_event, produce_resource_matcher,
&produce_resource_query);
DetermineHierarchy(&route, top_level_event, release_contents_matcher,
&release_contents_query);
}
BufferToEvents per_buffer_chrome_events;
// Only exo:Surface::Attach has app id argument.
ProcessChromeEvents(common_model, attach_surface_query,
&per_buffer_chrome_events, buffer_id_to_task_id);
ProcessChromeEvents(common_model, release_contents_query,
&per_buffer_chrome_events,
nullptr /* buffer_id_to_task_id */);
// Handle ProduceTransferableResource events. They have extra link to barrier
// events. Use buffer_id to bind events for the same graphics buffer.
const ArcTracingModel::TracingEventPtrs produce_resource_events =
common_model.Select(produce_resource_query);
std::map<int, std::string> put_offset_to_buffer_id_map;
for (const ArcTracingEvent* event : produce_resource_events) {
const std::string buffer_id = event->GetArgAsString(
kArgumentBufferId, std::string() /* default_value */);
if (buffer_id.empty()) {
LOG(ERROR) << "Failed to get buffer id from event: " << event->ToString();
continue;
}
ArcTracingGraphicsModel::BufferEvents& graphics_events =
per_buffer_chrome_events[buffer_id];
GetEventMapper().Produce(*event, &graphics_events);
const ArcTracingModel::TracingEventPtrs ordering_barrier_events =
common_model.Select(event, kBarrierOrderingSubQuery);
if (ordering_barrier_events.size() != 1) {
LOG(ERROR) << "Expected only one " << kBarrierOrderingSubQuery << ". Got "
<< ordering_barrier_events.size();
continue;
}
const int put_offset = ordering_barrier_events[0]->GetArgAsInteger(
kArgumentPutOffset, 0 /* default_value */);
if (!put_offset) {
LOG(ERROR) << "No " << kArgumentPutOffset
<< " argument in: " << ordering_barrier_events[0]->ToString();
continue;
}
if (put_offset_to_buffer_id_map.count(put_offset) &&
put_offset_to_buffer_id_map[put_offset] != buffer_id) {
LOG(ERROR) << put_offset << " is already mapped to "
<< put_offset_to_buffer_id_map[put_offset]
<< ". Skip mapping to " << buffer_id;
continue;
}
put_offset_to_buffer_id_map[put_offset] = buffer_id;
GetEventMapper().Produce(*ordering_barrier_events[0], &graphics_events);
}
// Find associated barrier flush event using put_offset argument.
const ArcTracingModel::TracingEventPtrs barrier_flush_events =
common_model.Select(barrier_flush_query);
for (const ArcTracingEvent* event : barrier_flush_events) {
const int put_offset =
event->GetArgAsInteger(kArgumentPutOffset, 0 /* default_value */);
if (!put_offset_to_buffer_id_map.count(put_offset))
continue;
ArcTracingGraphicsModel::BufferEvents& graphics_events =
per_buffer_chrome_events[put_offset_to_buffer_id_map[put_offset]];
GetEventMapper().Produce(*event, &graphics_events);
}
// Handle BufferInUse async events.
const ArcTracingModel::TracingEventPtrs buffer_in_use_events =
common_model.Select(kBufferInUseQuery);
std::map<std::string, std::string> buffer_in_use_id_to_buffer_id;
for (const ArcTracingEvent* event : buffer_in_use_events) {
// Only start event has buffer_id association.
if (event->GetPhase() != TRACE_EVENT_PHASE_ASYNC_BEGIN)
continue;
const std::string id = event->GetId();
const std::string buffer_id = event->GetArgAsString(
kArgumentBufferId, std::string() /* default_value */);
if (buffer_id.empty() || id.empty()) {
LOG(ERROR) << "Cannot map id to buffer id for event: "
<< event->ToString();
continue;
}
if (buffer_in_use_id_to_buffer_id.count(id) &&
buffer_in_use_id_to_buffer_id[id] != buffer_id) {
LOG(ERROR) << id << " is already mapped to "
<< buffer_in_use_id_to_buffer_id[id] << ". Skip mapping to "
<< buffer_id;
continue;
}
buffer_in_use_id_to_buffer_id[id] = buffer_id;
}
for (const ArcTracingEvent* event : buffer_in_use_events) {
if (event->GetPhase() != TRACE_EVENT_PHASE_ASYNC_STEP_INTO)
continue;
const std::string id = event->GetId();
if (!buffer_in_use_id_to_buffer_id.count(id)) {
LOG(ERROR) << "Found non-mapped event: " << event->ToString();
continue;
}
ArcTracingGraphicsModel::BufferEvents& graphics_events =
per_buffer_chrome_events[buffer_in_use_id_to_buffer_id[id]];
GetEventMapper().Produce(*event, &graphics_events);
}
for (auto& buffer : per_buffer_chrome_events)
SortBufferEventsByTimestamp(&buffer.second);
return per_buffer_chrome_events;
}
// Helper that finds a event of particular type in the list of events |events|
// starting from the index |start_index|. Returns |kInvalidBufferIndex| if event
// cannot be found.
ssize_t FindEvent(const ArcTracingGraphicsModel::BufferEvents& events,
BufferEventType type,
size_t start_index) {
for (size_t i = start_index; i < events.size(); ++i) {
if (events[i].type == type)
return i;
}
return kInvalidBufferIndex;
}
// Helper that finds valid pair of events for acquire/release buffer.
// |kBufferQueueReleased| should go immediately after |kBufferQueueAcquire|
// event with one exception of |kBufferQueueDequeueStart| that is allowed due to
// asynchronous flow of requesting buffers in Android. Returns
// |kInvalidBufferIndex| if such pair cannot be found.
ssize_t FindAcquireReleasePair(
const ArcTracingGraphicsModel::BufferEvents& events,
size_t start_index) {
const ssize_t index_acquire =
FindEvent(events, BufferEventType::kBufferQueueAcquire, start_index);
if (index_acquire == kInvalidBufferIndex)
return kInvalidBufferIndex;
// kBufferQueueDequeueStart is allowed between kBufferQueueAcquire and
// kBufferQueueReleased.
for (size_t i = index_acquire + 1; i < events.size(); ++i) {
if (events[i].type == BufferEventType::kBufferQueueDequeueStart) {
continue;
}
if (events[i].type == BufferEventType::kBufferQueueReleased) {
return index_acquire;
}
break;
}
return kInvalidBufferIndex;
}
// Helper that performs bisection search of event of type |type| in the ordered
// list of events |events|. Found event should have timestamp not later than
// |timestamp|. Returns |kInvalidBufferIndex| in case event is not found.
ssize_t FindNotLaterThan(const ArcTracingGraphicsModel::BufferEvents& events,
BufferEventType type,
int64_t timestamp) {
if (events.empty() || events[0].timestamp > timestamp)
return kInvalidBufferIndex;
size_t min_range = 0;
size_t result = events.size() - 1;
while (events[result].timestamp > timestamp) {
const size_t next = (result + min_range + 1) / 2;
if (events[next].timestamp <= timestamp)
min_range = next;
else
result = next - 1;
}
for (ssize_t i = result; i >= 0; --i) {
if (events[i].type == type)
return i;
}
return kInvalidBufferIndex;
}
// Tries to match Android graphics buffer events and Chrome graphics buffer
// events. There is no direct id usable to say if the same buffer is used or
// not. This tests if two set of events potentially belong the same buffer and
// return the maximum number of matching sequences. In case impossible
// combination is found then it returns 0 score. Impossible combination for
// example when we detect Chrome buffer was attached while it was not held by
// Android between |kBufferQueueAcquire| and |kBufferQueueRelease.
// The process of merging buffers continues while we can merge something. At
// each iteration buffers with maximum merge score get merged. Practically,
// having 20+ cycles (assuming 4 buffers in use) is enough to exactly identify
// the same buffer in Chrome and Android. If needed more similar checks can be
// added.
size_t GetMergeScore(
const ArcTracingGraphicsModel::BufferEvents& surface_flinger_events,
const ArcTracingGraphicsModel::BufferEvents& chrome_events) {
ssize_t attach_index = -1;
ssize_t acquire_index = -1;
while (true) {
acquire_index =
FindAcquireReleasePair(surface_flinger_events, acquire_index + 1);
if (acquire_index == kInvalidBufferIndex)
return 0;
attach_index =
FindNotLaterThan(chrome_events, BufferEventType::kExoSurfaceAttach,
surface_flinger_events[acquire_index + 1].timestamp);
if (attach_index >= 0)
break;
}
// From here buffers must be in sync. Attach should happen between acquire and
// release.
size_t score = 0;
while (true) {
const int64_t timestamp_from =
surface_flinger_events[acquire_index].timestamp;
const int64_t timestamp_to =
surface_flinger_events[acquire_index + 1].timestamp;
const int64_t timestamp = chrome_events[attach_index].timestamp;
if (timestamp < timestamp_from || timestamp > timestamp_to) {
return 0;
}
acquire_index =
FindAcquireReleasePair(surface_flinger_events, acquire_index + 2);
attach_index = FindEvent(chrome_events, BufferEventType::kExoSurfaceAttach,
attach_index + 1);
if (acquire_index == kInvalidBufferIndex ||
attach_index == kInvalidBufferIndex) {
break;
}
++score;
}
return score;
}
// Adds jank events into |ArcTracingGraphicsModel::EventsContainer|.
// |pulse_event_type| defines the type of the event that should appear
// periodically. Once it is missed in analyzed buffer events, new jank event is
// added. |jank_event_type| defines the type of jank.
void AddJanks(ArcTracingGraphicsModel::EventsContainer* result,
BufferEventType pulse_event_type,
BufferEventType jank_event_type) {
// Detect rate first.
BufferEvents pulse_events;
for (const auto& it : result->buffer_events()) {
for (const auto& it_event : it) {
if (it_event.type == pulse_event_type)
pulse_events.emplace_back(it_event);
}
}
SortBufferEventsByTimestamp(&pulse_events);
ArcGraphicsJankDetector jank_detector(base::BindRepeating(
[](BufferEventType jank_event_type, BufferEvents* out_janks,
const base::Time& timestamp) {
out_janks->emplace_back(
BufferEvent(jank_event_type,
timestamp.ToDeltaSinceWindowsEpoch().InMicroseconds()));
},
jank_event_type, &result->global_events()));
for (const auto& it : pulse_events) {
jank_detector.OnSample(base::Time::FromDeltaSinceWindowsEpoch(
base::TimeDelta::FromMicroseconds(it.timestamp)));
if (jank_detector.stage() == ArcGraphicsJankDetector::Stage::kActive)
break;
}
// At this point, no janks should be reported. We are detecting the rate.
if (jank_detector.stage() != ArcGraphicsJankDetector::Stage::kActive)
return;
// Period is defined. Pass all samples to detect janks.
jank_detector.SetPeriodFixed(jank_detector.period());
for (const auto& it : pulse_events) {
jank_detector.OnSample(base::Time::FromDeltaSinceWindowsEpoch(
base::TimeDelta::FromMicroseconds(it.timestamp)));
}
}
// Helper that performs query in |common_model| for top level Chrome GPU events
// and returns bands of sorted list of built events.
void GetChromeTopLevelEvents(const ArcTracingModel& common_model,
ArcTracingGraphicsModel::EventsContainer* result) {
// There is a chance that Chrome top level events may overlap. This may happen
// in case on non-trivial GPU load. In this case notification about swap or
// presentation done may come after the next frame draw is started. As a
// result, it leads to confusion in case displayed on the same event band.
// Solution is to allocate extra band and interchange events per buffer.
// Events are grouped per frame's id that starts from 0x100000000 and has
// monotonous increment. So we can simple keep it in the tree map that
// provides us the right ordering.
std::map<std::string, std::vector<const ArcTracingEvent*>> per_frame_events;
for (const ArcTracingEvent* event :
common_model.Select(kChromeTopEventsQuery)) {
per_frame_events[event->GetId()].emplace_back(event);
}
size_t band_index = 0;
result->buffer_events().resize(2);
for (const auto& it_frame : per_frame_events) {
for (const ArcTracingEvent* event : it_frame.second)
GetEventMapper().Produce(*event, &result->buffer_events()[band_index]);
band_index = (band_index + 1) % result->buffer_events().size();
}
for (auto& chrome_top_level_band : result->buffer_events())
SortBufferEventsByTimestamp(&chrome_top_level_band);
AddJanks(result, BufferEventType::kChromeOSDraw,
BufferEventType::kChromeOSJank);
}
// Helper that extracts top level Android events, such as refresh, vsync.
void GetAndroidTopEvents(const ArcTracingModel& common_model,
ArcTracingGraphicsModel::EventsContainer* result) {
result->buffer_events().resize(1);
for (const ArcTracingEvent* event :
common_model.Select(kHandleMessageRefreshQuery)) {
GetEventMapper().Produce(*event, &result->buffer_events()[0]);
}
for (const ArcTracingEvent* event :
common_model.Select(kHandleMessageInvalidateQuery)) {
GetEventMapper().Produce(*event, &result->buffer_events()[0]);
}
for (const ArcTracingEvent* event : common_model.Select(kVsyncQuery0))
GetEventMapper().Produce(*event, &result->global_events());
for (const ArcTracingEvent* event : common_model.Select(kVsyncQuery1))
GetEventMapper().Produce(*event, &result->global_events());
SortBufferEventsByTimestamp(&result->buffer_events()[0]);
AddJanks(result, BufferEventType::kSurfaceFlingerCompositionStart,
BufferEventType::kSurfaceFlingerCompositionJank);
SortBufferEventsByTimestamp(&result->global_events());
}
// Helper that serializes events |events| to the |base::ListValue|.
base::ListValue SerializeEvents(
const ArcTracingGraphicsModel::BufferEvents& events) {
base::ListValue list;
for (const auto& event : events) {
base::ListValue event_value;
event_value.GetList().push_back(base::Value(static_cast<int>(event.type)));
event_value.GetList().push_back(
base::Value(static_cast<double>(event.timestamp)));
list.GetList().emplace_back(std::move(event_value));
}
return list;
}
// Helper that serializes |events| to the |base::DictionaryValue|.
base::DictionaryValue SerializeEventsContainer(
const ArcTracingGraphicsModel::EventsContainer& events) {
base::DictionaryValue dictionary;
base::ListValue buffer_list;
for (auto& buffer : events.buffer_events())
buffer_list.GetList().emplace_back(SerializeEvents(buffer));
dictionary.SetKey(kKeyBuffers, std::move(buffer_list));
dictionary.SetKey(kKeyGlobalEvents, SerializeEvents(events.global_events()));
return dictionary;
}
bool IsInRange(BufferEventType type,
BufferEventType type_from_inclusive,
BufferEventType type_to_inclusive) {
return type >= type_from_inclusive && type <= type_to_inclusive;
}
// Helper that loads events from |base::Value|. Returns true in case events were
// read successfully. Events must be sorted and be known.
bool LoadEvents(const base::Value* value,
ArcTracingGraphicsModel::BufferEvents* out_events) {
DCHECK(out_events);
if (!value || !value->is_list())
return false;
int64_t previous_timestamp = 0;
for (const auto& entry : value->GetList()) {
if (!entry.is_list() || entry.GetList().size() != 2)
return false;
if (!entry.GetList()[0].is_int())
return false;
const BufferEventType type =
static_cast<BufferEventType>(entry.GetList()[0].GetInt());
if (!IsInRange(type, BufferEventType::kBufferQueueDequeueStart,
BufferEventType::kBufferFillJank) &&
!IsInRange(type, BufferEventType::kExoSurfaceAttach,
BufferEventType::kExoJank) &&
!IsInRange(type, BufferEventType::kChromeBarrierOrder,
BufferEventType::kChromeBarrierFlush) &&
!IsInRange(type, BufferEventType::kVsync,
BufferEventType::kSurfaceFlingerCompositionDone) &&
!IsInRange(type, BufferEventType::kVsync,
BufferEventType::kSurfaceFlingerCompositionJank) &&
!IsInRange(type, BufferEventType::kChromeOSDraw,
BufferEventType::kChromeOSJank)) {
return false;
}
if (!entry.GetList()[1].is_double() && !entry.GetList()[1].is_int())
return false;
const int64_t timestamp = entry.GetList()[1].GetDouble();
if (timestamp < previous_timestamp)
return false;
out_events->emplace_back(
ArcTracingGraphicsModel::BufferEvent(type, timestamp));
previous_timestamp = timestamp;
}
return true;
}
bool LoadEventsContainer(const base::Value* value,
ArcTracingGraphicsModel::EventsContainer* out_events) {
DCHECK(out_events->buffer_events().empty());
DCHECK(out_events->global_events().empty());
if (!value || !value->is_dict())
return false;
const base::DictionaryValue* dictionary = nullptr;
value->GetAsDictionary(&dictionary);
DCHECK(dictionary);
const base::Value* buffer_entries =
dictionary->FindKeyOfType(kKeyBuffers, base::Value::Type::LIST);
if (!buffer_entries)
return false;
for (const auto& buffer_entry : buffer_entries->GetList()) {
BufferEvents events;
if (!LoadEvents(&buffer_entry, &events))
return false;
out_events->buffer_events().emplace_back(std::move(events));
}
const base::Value* const global_events =
dictionary->FindKeyOfType(kKeyGlobalEvents, base::Value::Type::LIST);
if (!LoadEvents(global_events, &out_events->global_events()))
return false;
return true;
}
} // namespace
ArcTracingGraphicsModel::BufferEvent::BufferEvent(BufferEventType type,
int64_t timestamp)
: type(type), timestamp(timestamp) {}
bool ArcTracingGraphicsModel::BufferEvent::operator==(
const BufferEvent& other) const {
return type == other.type && timestamp == other.timestamp;
}
ArcTracingGraphicsModel::ViewId::ViewId(int task_id,
const std::string& activity)
: task_id(task_id), activity(activity) {}
bool ArcTracingGraphicsModel::ViewId::operator<(const ViewId& other) const {
if (task_id != other.task_id)
return task_id < other.task_id;
return activity.compare(other.activity) < 0;
}
bool ArcTracingGraphicsModel::ViewId::operator==(const ViewId& other) const {
return task_id == other.task_id && activity == other.activity;
}
ArcTracingGraphicsModel::ArcTracingGraphicsModel() = default;
ArcTracingGraphicsModel::~ArcTracingGraphicsModel() = default;
bool ArcTracingGraphicsModel::Build(const ArcTracingModel& common_model) {
Reset();
BufferToEvents per_buffer_surface_flinger_events =
GetSurfaceFlingerEvents(common_model);
BufferToEvents per_buffer_chrome_events =
GetChromeEvents(common_model, &chrome_buffer_id_to_task_id_);
// Try to merge surface flinger events and Chrome events. See |GetMergeScore|
// for more details.
while (true) {
size_t max_merge_score = 0;
std::string surface_flinger_buffer_id;
std::string chrome_buffer_id;
for (const auto& surface_flinger_buffer :
per_buffer_surface_flinger_events) {
for (const auto& chrome_buffer : per_buffer_chrome_events) {
const size_t merge_score =
GetMergeScore(surface_flinger_buffer.second, chrome_buffer.second);
if (merge_score > max_merge_score) {
max_merge_score = merge_score;
surface_flinger_buffer_id = surface_flinger_buffer.first;
chrome_buffer_id = chrome_buffer.first;
}
}
}
if (!max_merge_score)
break; // No more merge candidates.
const ViewId view_id(GetTaskIdFromBufferName(chrome_buffer_id),
GetActivityFromBufferName(surface_flinger_buffer_id));
std::vector<BufferEvents>& view_buffers =
view_buffers_[view_id].buffer_events();
view_buffers.push_back(std::move(
per_buffer_surface_flinger_events[surface_flinger_buffer_id]));
per_buffer_surface_flinger_events.erase(surface_flinger_buffer_id);
view_buffers.back().insert(
view_buffers.back().end(),
per_buffer_chrome_events[chrome_buffer_id].begin(),
per_buffer_chrome_events[chrome_buffer_id].end());
per_buffer_chrome_events.erase(chrome_buffer_id);
SortBufferEventsByTimestamp(&view_buffers.back());
}
for (auto& buffer : per_buffer_surface_flinger_events) {
LOG(WARNING) << "Failed to merge events for buffer: " << buffer.first;
view_buffers_[ViewId(-1 /* task_id */,
GetActivityFromBufferName(buffer.first))]
.buffer_events()
.emplace_back(std::move(buffer.second));
}
for (auto& buffer : per_buffer_chrome_events) {
LOG(WARNING) << "Failed to merge events for buffer: " << buffer.first;
view_buffers_[ViewId(GetTaskIdFromBufferName(buffer.first),
kUnknownActivity)]
.buffer_events()
.emplace_back(std::move(buffer.second));
}
if (view_buffers_.empty()) {
LOG(ERROR) << "No buffer events";
return false;
}
for (auto& it : view_buffers_) {
AddJanks(&it.second, BufferEventType::kBufferQueueDequeueStart,
BufferEventType::kBufferFillJank);
AddJanks(&it.second, BufferEventType::kExoSurfaceAttach,
BufferEventType::kExoJank);
SortBufferEventsByTimestamp(&it.second.global_events());
}
GetChromeTopLevelEvents(common_model, &chrome_top_level_);
if (chrome_top_level_.buffer_events().empty()) {
LOG(ERROR) << "No Chrome top events";
return false;
}
GetAndroidTopEvents(common_model, &android_top_level_);
if (android_top_level_.buffer_events().empty()) {
LOG(ERROR) << "No Android events";
return false;
}
cpu_model_.CopyFrom(common_model.cpu_model());
NormalizeTimestamps();
return true;
}
void ArcTracingGraphicsModel::NormalizeTimestamps() {
std::vector<BufferEvents*> all_buffers;
for (auto& view : view_buffers_) {
for (auto& buffer : view.second.buffer_events())
all_buffers.emplace_back(&buffer);
all_buffers.emplace_back(&view.second.global_events());
}
for (auto& buffer : android_top_level_.buffer_events())
all_buffers.emplace_back(&buffer);
all_buffers.emplace_back(&android_top_level_.global_events());
for (auto& buffer : chrome_top_level_.buffer_events())
all_buffers.emplace_back(&buffer);
all_buffers.emplace_back(&chrome_top_level_.global_events());
int64_t min = std::numeric_limits<int64_t>::max();
int64_t max = std::numeric_limits<int64_t>::min();
for (const BufferEvents* buffer : all_buffers) {
if (!buffer->empty()) {
min = std::min(min, buffer->front().timestamp);
max = std::max(max, buffer->back().timestamp);
}
}
for (const auto& cpu_events : cpu_model_.all_cpu_events()) {
if (!cpu_events.empty()) {
min = std::min(min, cpu_events.front().timestamp);
max = std::max(max, cpu_events.back().timestamp);
}
}
duration_ = max - min + 1;
for (BufferEvents* buffer : all_buffers) {
for (auto& event : *buffer)
event.timestamp -= min;
}
for (auto& cpu_events : cpu_model_.all_cpu_events()) {
for (auto& cpu_event : cpu_events)
cpu_event.timestamp -= min;
}
}
void ArcTracingGraphicsModel::Reset() {
chrome_top_level_.Reset();
android_top_level_.Reset();
view_buffers_.clear();
chrome_buffer_id_to_task_id_.clear();
cpu_model_.Reset();
duration_ = 0;
}
int ArcTracingGraphicsModel::GetTaskIdFromBufferName(
const std::string& chrome_buffer_name) const {
const auto it = chrome_buffer_id_to_task_id_.find(chrome_buffer_name);
if (it == chrome_buffer_id_to_task_id_.end())
return -1;
return it->second;
}
std::unique_ptr<base::DictionaryValue> ArcTracingGraphicsModel::Serialize()
const {
std::unique_ptr<base::DictionaryValue> root =
std::make_unique<base::DictionaryValue>();
// Views
base::ListValue view_list;
for (auto& view : view_buffers_) {
base::DictionaryValue view_value = SerializeEventsContainer(view.second);
view_value.SetKey(kKeyActivity, base::Value(view.first.activity));
view_value.SetKey(kKeyTaskId, base::Value(view.first.task_id));
view_list.GetList().emplace_back(std::move(view_value));
}
root->SetKey(kKeyViews, std::move(view_list));
// Android top events.
root->SetKey(kKeyAndroid, SerializeEventsContainer(android_top_level_));
// Chrome top events
root->SetKey(kKeyChrome, SerializeEventsContainer(chrome_top_level_));
// CPU.
root->SetKey(kKeyCpu, cpu_model_.Serialize());
// Duration.
root->SetKey(kKeyDuration, base::Value(static_cast<double>(duration_)));
return root;
}
std::string ArcTracingGraphicsModel::SerializeToJson() const {
std::unique_ptr<base::DictionaryValue> root = Serialize();
DCHECK(root);
std::string output;
if (!base::JSONWriter::WriteWithOptions(
*root, base::JSONWriter::OPTIONS_PRETTY_PRINT, &output)) {
LOG(ERROR) << "Failed to serialize model";
}
return output;
}
bool ArcTracingGraphicsModel::LoadFromJson(const std::string& json_data) {
Reset();
const std::unique_ptr<base::DictionaryValue> root =
base::DictionaryValue::From(base::JSONReader::ReadDeprecated(json_data));
if (!root)
return false;
return LoadFromValue(*root);
}
bool ArcTracingGraphicsModel::LoadFromValue(const base::DictionaryValue& root) {
Reset();
const base::Value* view_list =
root.FindKeyOfType(kKeyViews, base::Value::Type::LIST);
if (!view_list || view_list->GetList().empty())
return false;
for (const auto& view_entry : view_list->GetList()) {
if (!view_entry.is_dict())
return false;
const base::Value* activity =
view_entry.FindKeyOfType(kKeyActivity, base::Value::Type::STRING);
const base::Value* task_id =
view_entry.FindKeyOfType(kKeyTaskId, base::Value::Type::INTEGER);
if (!activity || !task_id)
return false;
const ViewId view_id(task_id->GetInt(), activity->GetString());
if (view_buffers_.find(view_id) != view_buffers_.end())
return false;
if (!LoadEventsContainer(&view_entry, &view_buffers_[view_id]))
return false;
}
if (!LoadEventsContainer(root.FindKey(kKeyAndroid), &android_top_level_))
return false;
if (!LoadEventsContainer(root.FindKey(kKeyChrome), &chrome_top_level_))
return false;
if (!cpu_model_.Load(root.FindKey(kKeyCpu)))
return false;
const base::Value* duration = root.FindKey(kKeyDuration);
if (!duration || (!duration->is_double() && !duration->is_int()))
return false;
duration_ = duration->GetDouble();
if (duration_ < 0)
return false;
return true;
}
ArcTracingGraphicsModel::EventsContainer::EventsContainer() = default;
ArcTracingGraphicsModel::EventsContainer::~EventsContainer() = default;
void ArcTracingGraphicsModel::EventsContainer::Reset() {
buffer_events_.clear();
global_events_.clear();
}
bool ArcTracingGraphicsModel::EventsContainer::operator==(
const EventsContainer& other) const {
return buffer_events() == other.buffer_events() &&
global_events() == other.global_events();
}
std::ostream& operator<<(std::ostream& os,
ArcTracingGraphicsModel::BufferEventType event_type) {
return os << static_cast<typename std::underlying_type<
ArcTracingGraphicsModel::BufferEventType>::type>(event_type);
}
} // namespace arc
| [
"[email protected]"
] | |
37cfb6b51ee834aea3006cd8a97296e6d1e097e4 | caf0f69e7fe1b10e3335c588e23e90c5bde93735 | /TheEasiestProblemIsThisOne.cpp | e19df35832b31e327b5fa8ac966c3978c077a2af | [] | no_license | danielrotta/kattis | 7380e9e013ead6ed68b0725e2174167d8e2729a2 | fd35c54979dbd9ffe4e22878b1b0072e55600aa6 | refs/heads/master | 2021-03-29T04:48:13.319105 | 2020-03-18T23:56:32 | 2020-03-18T23:56:32 | 247,920,889 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 608 | cpp | #include <bits/stdc++.h>
using namespace std;
/**
*
* @author Daniel Rotta ([email protected])
* @version 8.8.2019
*/
static int N = 0, p = 11;
int sum (int sumIn);
int main() {
//improves reading and writing speeds.
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
while (N != 0) {
while (sum(N) != sum(p * N)) {
p++;
}
cout << p << "\n";
cin >> N;
p = 11;
}
}
int sum (int sumIn) {
int output = 0;
while (sumIn != 0) {
output += sumIn % 10;
sumIn = sumIn / 10;
}
return output;
}
| [
"[email protected]"
] | |
8aec2ebcfa45a41e46f1ea4f7dfbb33ac84b5613 | e5a8f4c3f504bcf357d7b3c20d82e8c5c1d2075f | /includes/scat/signal.hpp | b6d0f5a9c796c95a72ace4eb20cec769c81be854 | [] | no_license | devast8a/scat | d92bedd7e764a4c308992a19d5c027eaf19d589a | d0aa1e09dcb7ff7426dbcec561dc86a02080035e | refs/heads/master | 2020-04-25T20:37:45.148235 | 2019-03-17T11:29:30 | 2019-03-17T11:29:30 | 173,054,723 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,150 | hpp | #ifndef SCAT_HEADER_SET_SIGNAL
#define SCAT_HEADER_SET_SIGNAL
#include <memory>
#include <vector>
// TODO: Make signal interface nicer
namespace scat {
namespace signal {
// TODO: Find a home for channel_t
using channel_t = size_t;
template<
class State,
class Reader
>
struct source {
public:
using sample_t = typename Reader::sample_t;
private:
chain_t chain; // TODO: Support universal chain?
channel_t channel;
Reader reader;
std::shared_ptr<State> state;
public:
source(
std::shared_ptr<State> state,
Reader reader,
channel_t channel
) : state(state),
reader(reader),
channel(channel)
{
}
std::vector<sample_t> read(){
return reader.read_channel(*state, channel, chain);
}
channel_t get_channel(){
return channel;
}
};
template<
class State,
class Reader
>
struct source_group {
public:
using sample_t = typename Reader::sample_t;
using source_t = source<State, Reader>;
private:
chain_t chain; // TODO: Support universal chain?
std::vector<channel_t> channels;
std::shared_ptr<State> state;
public:
Reader reader;
source_group(
std::shared_ptr<State> state,
Reader reader
) : state(state),
reader(reader)
{
// Register for all channels
// TODO: Abstract away from prime_probe specific state
channels.reserve(state->sets.size());
for(channel_t channel = 0; channel < state->sets.size(); channel += 1){
channels.push_back(channel);
}
}
std::vector<std::vector<sample_t>> read(
){
return reader.read_channels(*state, channels, chain);
};
std::vector<sample_t> read_channel(
channel_t channel
){
return reader.read_channel(*state, channel, chain);
}
std::vector<channel_t>& get_channels(){
return channels;
}
source_t channel_to_source(channel_t channel){
return source_t(state, reader, channel);
}
std::vector<source_t> get_sources(){
std::vector<source_t> sources;
sources.reserve(channels.size());
for(auto channel : channels){
sources.emplace_back(state, reader, channel);
}
return sources;
}
};
template<typename T>
struct length {
T value;
size_t length;
size_t start;
};
template<typename T>
std::vector<length<T>> samples_to_lengths(
std::vector<T> const& samples,
size_t const minimum_gap = 0
){
std::vector<length<T>> output;
size_t index = 1;
size_t length = 1;
size_t start = 0;
T value = samples[0];
while(index < samples.size()){
if(value != samples[index]){
if(length <= minimum_gap && output.size() > 0){
auto prev = output.back();
value = prev.value;
start = prev.start;
length += prev.length;
output.pop_back();
} else {
output.push_back({value, length, start});
start = index;
length = 0;
value = samples[index];
}
}
index += 1;
length += 1;
}
output.push_back({value, length, start});
return output;
}
template<typename T>
std::vector<T> lengths_to_samples(
std::vector<length<T>> const& lengths
){
std::vector<T> samples;
for(auto length : lengths){
for(size_t i = 0; i < length.length; i += 1){
samples.push_back(length.value);
}
}
return samples;
}
template<typename T>
std::vector<T> low_pass(std::vector<T> samples, size_t freq){
auto lengths = samples_to_lengths(samples, freq);
return lengths_to_samples(lengths);
}
template<typename T>
std::vector<T> threshold_samples(
std::vector<T>& samples,
T high = 1
){
// Find threshold
T optimal_threshold = 0;
size_t value = 100000000;
for(T threshold = 1; threshold < 16; threshold++){
size_t zero = 0;
size_t one = 0;
for(auto value : samples){
if(value >= threshold){
one += 1;
} else {
zero += 1;
}
}
size_t difference = (zero > one) ? (zero - one) : (one - zero);
if(difference < value){
value = difference;
optimal_threshold = threshold;
}
}
// Apply threshold
for(size_t i = 0; i < samples.size(); ++i){
samples[i] = (samples[i] >= optimal_threshold) ? high : 0;
}
return samples;
}
struct signal {
size_t start;
size_t end;
std::vector<length<int16_t>> data;
size_t one_timestep;
size_t zero_timestep;
};
std::vector<bool> decode_binary(signal const& signal, size_t bits){
std::vector<bool> results;
for(size_t index = signal.end; index < signal.data.size(); ++index){
auto length = signal.data[index];
bool value = (length.value == 1);
float c = ((float)length.length) / (value ? signal.one_timestep : signal.zero_timestep);
size_t count = std::lround(c);
for(size_t i = 0; i < count; ++i){
results.push_back(value);
if(results.size() >= bits){
return results;
}
}
}
return results;
}
template<typename Sources>
std::unique_ptr<signal> find_first(
std::vector<int16_t> known,
Sources& sources
){
auto signal_lengths = samples_to_lengths(known);
size_t minimum_gap = 6;
size_t zero_signal_sum = 0;
size_t one_signal_sum = 0;
for(auto length : signal_lengths){
if(length.value == 0){
zero_signal_sum += length.length;
} else {
one_signal_sum += length.length;
}
}
for(auto source : sources.get_channels()){
auto data = sources.read_channel(source);
data = threshold_samples(data);
auto lengths = samples_to_lengths(data, minimum_gap);
// Find singal from lengths
size_t window_start = 0;
size_t window_end = signal_lengths.size();
while(window_end < lengths.size()){
size_t zero_window_sum = 0;
size_t one_window_sum = 0;
for(size_t index = window_start; index < window_end; ++index){
if(lengths[index].value == 0){
zero_window_sum += lengths[index].length;
} else {
one_window_sum += lengths[index].length;
}
}
size_t one_timestep = one_window_sum / one_signal_sum;
size_t zero_timestep = zero_window_sum / zero_signal_sum;
float max_tolerance = 0;
// Compare the window with our signal
for(size_t index = window_start; index < window_end; ++index){
size_t timestep = (lengths[index].value == 0) ? zero_timestep : one_timestep;
size_t s = signal_lengths[index - window_start].length * timestep;
size_t w = lengths[index].length;
size_t difference = (s > w) ? (s - w) : (w - s);
float tolerance = ((float)difference) / s;
if(tolerance >= max_tolerance){
max_tolerance = tolerance;
}
}
if(max_tolerance <= 0.4){
auto result = std::make_unique<signal>();
result->start = window_start;
result->end = window_end;
result->data = lengths;
result->one_timestep = one_timestep;
result->zero_timestep = zero_timestep;
return result;
}
window_start += 1;
window_end += 1;
}
}
return nullptr;
}
std::vector<int16_t> repeat(std::vector<int16_t>&& input, size_t count){
std::vector<int16_t> output;
for(size_t i = 0; i < count; ++i){
output.insert(output.end(), input.begin(), input.end());
}
return output;
}
} // namespace signal
} // namespace scat
#endif // SCAT_HEADER_SET_SIGNAL
| [
"[email protected]"
] | |
f33d1e6e774389728e2239859425321d5d1f6ddc | 34ec47abbff08f1b44af46e6d414242c4c079054 | /heapsort.cpp | 2da8204d14075f8482b1db78473b9ee231993ed0 | [] | no_license | gccross/snippets | 9b6692f9c31d1c06eb254800b3b07ed42af20625 | 6664702f442b97483aed9a029c5b70bbd5fa294a | refs/heads/master | 2021-01-11T12:36:04.760083 | 2020-10-04T18:06:00 | 2020-10-04T18:06:00 | 76,301,599 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,517 | cpp | #include <deque>
#include <iostream>
#include <functional>
using namespace std;
template <typename T, typename C>
void heapify(T arr[], size_t n, size_t i, C cmp)
{
deque<size_t> dq {i};
while (!dq.empty())
{
size_t cur = dq.front();
dq.pop_front();
if (cur < n)
{
size_t largest = i;
size_t l = 2*i + 1;
size_t r = 2*i + 2;
if (l < n && cmp(arr[l], arr[largest]))
largest = l;
if (r < n && cmp(arr[r], arr[largest]))
largest = r;
if (i != largest)
{
swap(arr[i], arr[largest]);
dq.push_back(largest);
}
}
}
}
template <typename T, typename C = std::greater<T>>
void make_heap(T arr[], size_t n, C cmp = std::greater<T>())
{
for (int i = n/2-1; i>=0; --i)
{
heapify(arr,n,i,cmp);
}
}
template <typename T, typename C = std::greater<T>>
void heap_sort(T arr[], size_t n, C cmp = std::greater<T>())
{
make_heap(arr, n, cmp);
for (size_t i = n-1; i>0; --i)
{
swap(arr[0],arr[i]);
make_heap(arr,i,cmp);
}
}
int main (int argc, char const * argv[])
{
cout << "Hello World " __FILE__ << endl;
string s("kitkatticklemyfat");
make_heap(s.data(), s.length());
cout << s << endl;
make_heap(s.data(), s.length(), std::less<char>());
cout << s << endl;
string s2 = "There was a crooked man, who lived in a crooked house.";
heap_sort(s2.data(), s2.length());
cout << s2 << endl;
string s3 = "There was a crooked man, who lived in a crooked house.";
heap_sort(s3.data(), s2.length(), std::less<char>());
cout << s3 << endl;
return 0;
}
| [
"[email protected]"
] | |
109787f86507364db3f33c8b66264f265586247d | 814bbf94e8cc5c56a98fda209203bf1cf5f25086 | /미분류/Baekjoon Online Judge/C++/BOJ_1629(pow함수 logn속도(repeated squaring)).cpp | f65fe9920de858f84c41c78340610b74962a43ac | [] | no_license | JW-1017/Algorithm | 9683fa71397a35855fc5ab7dc3dbfd8ea1d04367 | 9c8a2d7b306f38f5d09c2d799bade8023eb10b5a | refs/heads/master | 2020-12-03T08:11:32.887244 | 2018-10-05T19:11:19 | 2018-10-05T19:11:19 | 95,330,636 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 635 | cpp | #include <iostream>
using namespace std;
/*
input
10 11 12
output
4
https://www.acmicpc.net/problem/1629
/* Copyright (C) 2017 by Son */
int main() {
long long val = 1;
long long num, exponent, mod; // num : 곱하는 수, exponent : 곱하는 횟수, mod : 나누는 수(나중에 안쓰임) pow(num, exponent)를 log(n)으로
cin >> num >> exponent >> mod;
// 지수를 2진수로 변환하여 곱 https://xlinux.nist.gov/dads/HTML/repeatedSquaring.html
while (exponent > 0) {
if (exponent % 2 == 1) {
val = (val * num) % mod;
}
exponent /= 2;
num = (num * num) % mod;
}
cout << val << endl;
return 0;
} | [
"[email protected]"
] | |
01925b0fd8798ebabc7eff7efc34e4ea23a709ae | 9f8245ba25bf794d176967a69dc18ccb92e814d5 | /MaxIncreasetoKeepCitySkyline.cpp | 72c2f55ad02838d2926afbf61e5dff53a969fad4 | [
"MIT"
] | permissive | Biswajee/Codestore | 80b86b9815cfd1d493105deec8512bc209f545d6 | 2428522b2af668d3797b98b57fc37419828c20b2 | refs/heads/master | 2023-07-04T04:18:22.242520 | 2021-08-07T15:51:05 | 2021-08-07T15:51:05 | 163,070,131 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 975 | cpp | #include <bits/stdc++.h>
#include <algorithm>
using namespace std;
class Solution {
public:
int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
vector<int> skylineV;
vector<int> skylineH;
skylineV.resize(grid.size());
skylineH.resize(grid[0].size());
for (size_t y = 0; y < grid.size(); ++y)
{
for (size_t x = 0; x < grid[y].size(); ++x)
{
skylineV[y] = max(skylineV[y], grid[y][x]);
skylineH[x] = max(skylineH[x], grid[y][x]);
}
}
int sum = 0, maxHeight = 0;
for (size_t y = 0; y < grid.size(); ++y)
{
for (size_t x = 0; x < grid[y].size(); ++x)
{
maxHeight = min(skylineH[x], skylineV[y]);
if (grid[y][x] < maxHeight) sum += maxHeight - grid[y][x];
}
}
return sum;
}
}; | [
"[email protected]"
] | |
c7aef2e9e98e411ed264678eded84a28e851b909 | acddced85122ee1b09f3378fcd36fb4443c37a8f | /src/qt/guiutil.cpp | ec87c9dad7e65dea439978199e01c44efe7a5bfd | [
"MIT"
] | permissive | zebbra2014/WildWestCoin | 546c9446d12cb7fe6d9abd3325e8fb58fc6c5325 | cb5c71765d697b9dedf4b82bbbbb2fe353e09c5a | refs/heads/master | 2021-01-15T15:25:12.956993 | 2014-05-13T20:44:58 | 2014-05-13T20:44:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,395 | cpp | #include "guiutil.h"
#include "bitcoinaddressvalidator.h"
#include "walletmodel.h"
#include "bitcoinunits.h"
#include "util.h"
#include "init.h"
#include <QString>
#include <QDateTime>
#include <QDoubleValidator>
#include <QFont>
#include <QLineEdit>
#include <QUrl>
#include <QTextDocument> // For Qt::escape
#include <QAbstractItemView>
#include <QApplication>
#include <QClipboard>
#include <QFileDialog>
#include <QDesktopServices>
#include <QThread>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#ifdef WIN32
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "shlwapi.h"
#include "shlobj.h"
#include "shellapi.h"
#endif
namespace GUIUtil {
QString dateTimeStr(const QDateTime &date)
{
return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") + date.toString("hh:mm");
}
QString dateTimeStr(qint64 nTime)
{
return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
}
QFont bitcoinAddressFont()
{
QFont font("Monospace");
font.setStyleHint(QFont::TypeWriter);
return font;
}
void setupAddressWidget(QLineEdit *widget, QWidget *parent)
{
widget->setMaxLength(BitcoinAddressValidator::MaxAddressLength);
widget->setValidator(new BitcoinAddressValidator(parent));
widget->setFont(bitcoinAddressFont());
}
void setupAmountWidget(QLineEdit *widget, QWidget *parent)
{
QDoubleValidator *amountValidator = new QDoubleValidator(parent);
amountValidator->setDecimals(8);
amountValidator->setBottom(0.0);
widget->setValidator(amountValidator);
widget->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
}
bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
{
// NovaCoin: check prefix
if(uri.scheme() != QString("wildwestcoin"))
return false;
SendCoinsRecipient rv;
rv.address = uri.path();
rv.amount = 0;
QList<QPair<QString, QString> > items = uri.queryItems();
for (QList<QPair<QString, QString> >::iterator i = items.begin(); i != items.end(); i++)
{
bool fShouldReturnFalse = false;
if (i->first.startsWith("req-"))
{
i->first.remove(0, 4);
fShouldReturnFalse = true;
}
if (i->first == "label")
{
rv.label = i->second;
fShouldReturnFalse = false;
}
else if (i->first == "amount")
{
if(!i->second.isEmpty())
{
if(!BitcoinUnits::parse(BitcoinUnits::BTC, i->second, &rv.amount))
{
return false;
}
}
fShouldReturnFalse = false;
}
if (fShouldReturnFalse)
return false;
}
if(out)
{
*out = rv;
}
return true;
}
bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
{
// Convert wildwestcoin:// to wildwestcoin:
//
// Cannot handle this later, because bitcoin:// will cause Qt to see the part after // as host,
// which will lower-case it (and thus invalidate the address).
if(uri.startsWith("wildwestcoin://"))
{
uri.replace(0, 12, "wildwestcoin:");
}
QUrl uriInstance(uri);
return parseBitcoinURI(uriInstance, out);
}
QString HtmlEscape(const QString& str, bool fMultiLine)
{
QString escaped = Qt::escape(str);
if(fMultiLine)
{
escaped = escaped.replace("\n", "<br>\n");
}
return escaped;
}
QString HtmlEscape(const std::string& str, bool fMultiLine)
{
return HtmlEscape(QString::fromStdString(str), fMultiLine);
}
void copyEntryData(QAbstractItemView *view, int column, int role)
{
if(!view || !view->selectionModel())
return;
QModelIndexList selection = view->selectionModel()->selectedRows(column);
if(!selection.isEmpty())
{
// Copy first item
QApplication::clipboard()->setText(selection.at(0).data(role).toString());
}
}
QString getSaveFileName(QWidget *parent, const QString &caption,
const QString &dir,
const QString &filter,
QString *selectedSuffixOut)
{
QString selectedFilter;
QString myDir;
if(dir.isEmpty()) // Default to user documents location
{
myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
}
else
{
myDir = dir;
}
QString result = QFileDialog::getSaveFileName(parent, caption, myDir, filter, &selectedFilter);
/* Extract first suffix from filter pattern "Description (*.foo)" or "Description (*.foo *.bar ...) */
QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
QString selectedSuffix;
if(filter_re.exactMatch(selectedFilter))
{
selectedSuffix = filter_re.cap(1);
}
/* Add suffix if needed */
QFileInfo info(result);
if(!result.isEmpty())
{
if(info.suffix().isEmpty() && !selectedSuffix.isEmpty())
{
/* No suffix specified, add selected suffix */
if(!result.endsWith("."))
result.append(".");
result.append(selectedSuffix);
}
}
/* Return selected suffix if asked to */
if(selectedSuffixOut)
{
*selectedSuffixOut = selectedSuffix;
}
return result;
}
Qt::ConnectionType blockingGUIThreadConnection()
{
if(QThread::currentThread() != QCoreApplication::instance()->thread())
{
return Qt::BlockingQueuedConnection;
}
else
{
return Qt::DirectConnection;
}
}
bool checkPoint(const QPoint &p, const QWidget *w)
{
QWidget *atW = qApp->widgetAt(w->mapToGlobal(p));
if (!atW) return false;
return atW->topLevelWidget() == w;
}
bool isObscured(QWidget *w)
{
return !(checkPoint(QPoint(0, 0), w)
&& checkPoint(QPoint(w->width() - 1, 0), w)
&& checkPoint(QPoint(0, w->height() - 1), w)
&& checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
&& checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
}
void openDebugLogfile()
{
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
/* Open debug.log with the associated application */
if (boost::filesystem::exists(pathDebug))
QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(pathDebug.string())));
}
ToolTipToRichTextFilter::ToolTipToRichTextFilter(int size_threshold, QObject *parent) :
QObject(parent), size_threshold(size_threshold)
{
}
bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt)
{
if(evt->type() == QEvent::ToolTipChange)
{
QWidget *widget = static_cast<QWidget*>(obj);
QString tooltip = widget->toolTip();
if(tooltip.size() > size_threshold && !tooltip.startsWith("<qt>") && !Qt::mightBeRichText(tooltip))
{
// Prefix <qt/> to make sure Qt detects this as rich text
// Escape the current message as HTML and replace \n by <br>
tooltip = "<qt>" + HtmlEscape(tooltip, true) + "<qt/>";
widget->setToolTip(tooltip);
return true;
}
}
return QObject::eventFilter(obj, evt);
}
#ifdef WIN32
boost::filesystem::path static StartupShortcutPath()
{
return GetSpecialFolderPath(CSIDL_STARTUP) / "wildwestcoin.lnk";
}
bool GetStartOnSystemStartup()
{
// check for Bitcoin.lnk
return boost::filesystem::exists(StartupShortcutPath());
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
// If the shortcut exists already, remove it for updating
boost::filesystem::remove(StartupShortcutPath());
if (fAutoStart)
{
CoInitialize(NULL);
// Get a pointer to the IShellLink interface.
IShellLink* psl = NULL;
HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL,
CLSCTX_INPROC_SERVER, IID_IShellLink,
reinterpret_cast<void**>(&psl));
if (SUCCEEDED(hres))
{
// Get the current executable path
TCHAR pszExePath[MAX_PATH];
GetModuleFileName(NULL, pszExePath, sizeof(pszExePath));
TCHAR pszArgs[5] = TEXT("-min");
// Set the path to the shortcut target
psl->SetPath(pszExePath);
PathRemoveFileSpec(pszExePath);
psl->SetWorkingDirectory(pszExePath);
psl->SetShowCmd(SW_SHOWMINNOACTIVE);
psl->SetArguments(pszArgs);
// Query IShellLink for the IPersistFile interface for
// saving the shortcut in persistent storage.
IPersistFile* ppf = NULL;
hres = psl->QueryInterface(IID_IPersistFile,
reinterpret_cast<void**>(&ppf));
if (SUCCEEDED(hres))
{
WCHAR pwsz[MAX_PATH];
// Ensure that the string is ANSI.
MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().string().c_str(), -1, pwsz, MAX_PATH);
// Save the link by calling IPersistFile::Save.
hres = ppf->Save(pwsz, TRUE);
ppf->Release();
psl->Release();
CoUninitialize();
return true;
}
psl->Release();
}
CoUninitialize();
return false;
}
return true;
}
#elif defined(LINUX)
// Follow the Desktop Application Autostart Spec:
// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
boost::filesystem::path static GetAutostartDir()
{
namespace fs = boost::filesystem;
char* pszConfigHome = getenv("XDG_CONFIG_HOME");
if (pszConfigHome) return fs::path(pszConfigHome) / "autostart";
char* pszHome = getenv("HOME");
if (pszHome) return fs::path(pszHome) / ".config" / "autostart";
return fs::path();
}
boost::filesystem::path static GetAutostartFilePath()
{
return GetAutostartDir() / "wildwestcoin.desktop";
}
bool GetStartOnSystemStartup()
{
boost::filesystem::ifstream optionFile(GetAutostartFilePath());
if (!optionFile.good())
return false;
// Scan through file for "Hidden=true":
std::string line;
while (!optionFile.eof())
{
getline(optionFile, line);
if (line.find("Hidden") != std::string::npos &&
line.find("true") != std::string::npos)
return false;
}
optionFile.close();
return true;
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
if (!fAutoStart)
boost::filesystem::remove(GetAutostartFilePath());
else
{
char pszExePath[MAX_PATH+1];
memset(pszExePath, 0, sizeof(pszExePath));
if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath)-1) == -1)
return false;
boost::filesystem::create_directories(GetAutostartDir());
boost::filesystem::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out|std::ios_base::trunc);
if (!optionFile.good())
return false;
// Write a bitcoin.desktop file to the autostart directory:
optionFile << "[Desktop Entry]\n";
optionFile << "Type=Application\n";
optionFile << "Name=wildwestcoin\n";
optionFile << "Exec=" << pszExePath << " -min\n";
optionFile << "Terminal=false\n";
optionFile << "Hidden=false\n";
optionFile.close();
}
return true;
}
#else
// TODO: OSX startup stuff; see:
// https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPSystemStartup/Articles/CustomLogin.html
bool GetStartOnSystemStartup() { return false; }
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
#endif
HelpMessageBox::HelpMessageBox(QWidget *parent) :
QMessageBox(parent)
{
header = tr("wildwestcoin-Qt") + " " + tr("version") + " " +
QString::fromStdString(FormatFullVersion()) + "\n\n" +
tr("Usage:") + "\n" +
" wildwestcoin-qt [" + tr("command-line options") + "] " + "\n";
coreOptions = QString::fromStdString(HelpMessage());
uiOptions = tr("UI options") + ":\n" +
" -lang=<lang> " + tr("Set language, for example \"de_DE\" (default: system locale)") + "\n" +
" -min " + tr("Start minimized") + "\n" +
" -splash " + tr("Show splash screen on startup (default: 1)") + "\n";
setWindowTitle(tr("wildwestcoin-Qt"));
setTextFormat(Qt::PlainText);
// setMinimumWidth is ignored for QMessageBox so put in non-breaking spaces to make it wider.
setText(header + QString(QChar(0x2003)).repeated(50));
setDetailedText(coreOptions + "\n" + uiOptions);
}
void HelpMessageBox::printToConsole()
{
// On other operating systems, the expected action is to print the message to the console.
QString strUsage = header + "\n" + coreOptions + "\n" + uiOptions;
fprintf(stdout, "%s", strUsage.toStdString().c_str());
}
void HelpMessageBox::showOrPrint()
{
#if defined(WIN32)
// On Windows, show a message box, as there is no stderr/stdout in windowed applications
exec();
#else
// On other operating systems, print help text to console
printToConsole();
#endif
}
} // namespace GUIUtil
| [
"[email protected]"
] | |
010f57db5b958cd4440cca06e36f866573e19363 | 3c54065067d47c765cb15dbed1cd021a0268f5ca | /cpp/tests/test_calibrate.cpp | 25f73f1eb295152b6fc891458192e68d045ca2b3 | [
"MIT"
] | permissive | mbaradad/corner-camera | 25dd6df389d061cc61561ca6cf82f7833f426a73 | b6e3308789075681f3f7b49a039bcf01ef61ded0 | refs/heads/master | 2021-04-15T16:30:44.910811 | 2018-11-13T15:16:32 | 2018-11-13T15:16:32 | 126,898,774 | 0 | 1 | null | 2018-03-26T22:47:18 | 2018-03-26T22:47:18 | null | UTF-8 | C++ | false | false | 875 | cpp | #include "CalibrationWindow.h"
int main()
{
const std::string datafolder = "/Users/vickieye/Dropbox (MIT)/shadowImaging/edgeImaging/data/testvideos_Mar04/";
// const std::string expfolder = datafolder + "experiments/";
const std::string expfolder = "/home/vickieye/Downloads/";
const std::string name = "blue_randomwalking1";
const std::string vidtype = ".MP4";
const std::string srcfile = expfolder + name + vidtype;
cv::VideoCapture cap(srcfile);
if (!cap.isOpened()) {
printf("Cannot read video from %s\n", srcfile.c_str());
return -1;
}
cv::Mat frame;
bool ok = cap.read(frame);
if (!ok) {
printf("Cannot read in frame\n");
return -1;
}
CalibrationWindow win("test", frame);
win.show();
std::cout << "corner: " << win.corner() << std::endl;
std::cout << "wallpt: " << win.wallPoint() << std::endl;
return 0;
}
| [
"[email protected]"
] | |
15c88f1915f9b03bc0e2aae3ca17684464a9b606 | 6848e01655aa970251c767f22f463517d687843a | /src/external/omplext_odeint/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp | 8ec3d6ce39135ef437700cc6983268c423dfa816 | [
"BSL-1.0",
"BSD-3-Clause"
] | permissive | davetcoleman/ompl-release | 893b574695fa9e8b39cd798a08316e1b5b006c88 | 1a58a9eeafa894cbf396146e2a7012f9eb7d694b | refs/heads/master | 2021-01-10T12:50:11.617516 | 2012-10-17T13:16:02 | 2012-10-17T13:16:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,069 | hpp | /*
[auto_generated]
boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
[begin_description]
Base class for all explicit Runge Kutta steppers.
[end_description]
Copyright 2009-2011 Karsten Ahnert
Copyright 2009-2011 Mario Mulansky
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef OMPLEXT_BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
#define OMPLEXT_BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <omplext_odeint/boost/numeric/odeint/util/bind.hpp>
#include <omplext_odeint/boost/numeric/odeint/util/unwrap_reference.hpp>
#include <omplext_odeint/boost/numeric/odeint/util/state_wrapper.hpp>
#include <omplext_odeint/boost/numeric/odeint/util/resizer.hpp>
#include <omplext_odeint/boost/numeric/odeint/util/is_resizeable.hpp>
#include <omplext_odeint/boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <omplext_odeint/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
namespace boost {
namespace numeric {
namespace omplext_odeint {
/*
* base class for explicit steppers
* models the stepper concept
*
* this class provides the following overloads
* do_step( sys , x , t , dt )
* do_step( sys , in , t , out , dt )
* do_step( sys , x , dxdt_in , t , dt )
* do_step( sys , in , dxdt_in , t , out , dt )
*/
template<
class Stepper ,
unsigned short Order ,
class State ,
class Value ,
class Deriv ,
class Time ,
class Algebra ,
class Operations ,
class Resizer
>
class explicit_stepper_base : public algebra_stepper_base< Algebra , Operations >
{
public:
typedef explicit_stepper_base< Stepper , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
typedef State state_type;
typedef Value value_type;
typedef Deriv deriv_type;
typedef Time time_type;
typedef Resizer resizer_type;
typedef Stepper stepper_type;
typedef stepper_tag stepper_category;
typedef state_wrapper< state_type > wrapped_state_type;
typedef state_wrapper< deriv_type > wrapped_deriv_type;
typedef typename algebra_stepper_base_type::algebra_type algebra_type;
typedef unsigned short order_type;
static const order_type order_value = Order;
explicit_stepper_base( const algebra_type &algebra = algebra_type() )
: algebra_stepper_base_type( algebra )
{ }
order_type order( void ) const
{
return order_value;
}
/*
* Version 1 : do_step( sys , x , t , dt )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut >
void do_step( System system , StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
template< class System , class StateInOut >
void do_step( System system , const StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/*
* Version 2 : do_step( sys , x , dxdt , t , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivIn >
typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
/*
* Version 3 : do_step( sys , in , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class StateOut >
void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
{
typename omplext_odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
sys( in , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
}
/*
* Version 4 : do_step( sys , in , dxdt , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class DerivIn , class StateOut >
void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
private:
stepper_type& stepper( void )
{
return *static_cast< stepper_type* >( this );
}
const stepper_type& stepper( void ) const
{
return *static_cast< const stepper_type* >( this );
}
template< class StateIn >
bool resize_impl( const StateIn &x )
{
return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
}
template< class System , class StateInOut >
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
{
typename omplext_odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
sys( x , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
}
resizer_type m_resizer;
protected:
wrapped_deriv_type m_dxdt;
};
} // odeint
} // numeric
} // boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
| [
"[email protected]"
] | |
bac87595ac507906a6fe341e609ac23f60387f8f | 6fe78b7418df203b4402a32b5c024b5ef5279060 | /platform/shared/logging/RhoLogCat.h | 9da7f73c4e2daf70a95e0ee4609112e42bed3b02 | [
"MIT"
] | permissive | heathsmith/rhodes | ccabe7ffa3ac3560f54f9984504befbb5173dabc | 4fde9286c92ce4f8ed072509624646319919fce7 | refs/heads/master | 2020-12-25T05:19:23.974102 | 2011-02-22T21:59:47 | 2011-02-22T21:59:47 | 1,399,930 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 901 | h | #ifndef _RHOLOGCAT_H_
#define _RHOLOGCAT_H_
#include "common/RhoPort.h"
#include "RhoLogConf.h"
namespace rho {
class LogCategory{
String m_strName;
public:
LogCategory(const char* szName = "") : m_strName(szName){}
const String& getName()const{ return m_strName; }
bool isEmpty()const{ return m_strName.length() == 0; }
};
}
extern rho::LogCategory __rhoCurrentCategory;
#define DEFINE_LOGCLASS static rho::LogCategory __rhoCurrentCategory;\
static rho::LogCategory getLogCategory(){return __rhoCurrentCategory;}
#define IMPLEMENT_LOGCLASS(classname, name) \
rho::LogCategory classname::__rhoCurrentCategory = name
#define DEFINE_BASELOGCLASS rho::LogCategory __rhoCurrentCategory;\
rho::LogCategory getLogCategory(){return __rhoCurrentCategory;}\
void setLogCategory(const rho::LogCategory& cat){__rhoCurrentCategory = cat;}
#endif //_RHOLOGCAT_H_
| [
"[email protected]"
] | |
1d36eaf85994ac1789769c7a80d80ae71baa35cd | ccb5f1b03b43b7b7dfaadf3142518d28f4097194 | /Create2DWindow/init.cpp | e1473552193a3a6402602b20d62e5fd722a23cac | [] | no_license | SonHai-code/Predator | 91cbd16eaeea104a4bb460902a802dd67e2d53eb | 23a90e59261b05cacdcb90b83bb771a91498fc55 | refs/heads/master | 2023-05-14T14:14:52.906544 | 2021-05-31T02:40:24 | 2021-05-31T02:40:24 | 372,358,843 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,096 | cpp |
#include "init.h"
void init()
{
int rendererFlags, windowFlags;
rendererFlags = SDL_RENDERER_ACCELERATED;
windowFlags = 0;
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
printf("Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024) == -1)
{
printf("Couldn't initialize SDL Mixer\n");
exit(1);
}
Mix_AllocateChannels(MAX_SND_CHANNELS);
app.window = SDL_CreateWindow("Parallel Realities", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, windowFlags);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
app.renderer = SDL_CreateRenderer(app.window, -1, rendererFlags);
IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG);
SDL_ShowCursor(0);
}
void initGame(void)
{
initBackground();
initStarfield();
initSounds();
initFonts();
initHighscoreTable();
memset(&stage, 0, sizeof(Stage));
loadMusic("D:\\game\\music\\What_s-Poppin-Freestyle-RPT-MCK.ogg");
playMusic(1);
}
void cleanup(void)
{
SDL_DestroyRenderer(app.renderer);
SDL_DestroyWindow(app.window);
SDL_Quit();
}
| [
"[email protected]"
] | |
b10169ee7b8fe4bb833cf38e84f6ce29ac519350 | 7e791eccdc4d41ba225a90b3918ba48e356fdd78 | /chromium/src/chrome/browser/ssl/bad_clock_blocking_page.h | 456df5508b2a4f0c8518e813b5dbc4c4120a1056 | [
"BSD-3-Clause"
] | permissive | WiViClass/cef-3.2623 | 4e22b763a75e90d10ebf9aa3ea9a48a3d9ccd885 | 17fe881e9e481ef368d9f26e903e00a6b7bdc018 | refs/heads/master | 2021-01-25T04:38:14.941623 | 2017-06-09T07:37:43 | 2017-06-09T07:37:43 | 93,824,379 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,842 | h | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_SSL_BAD_CLOCK_BLOCKING_PAGE_H_
#define CHROME_BROWSER_SSL_BAD_CLOCK_BLOCKING_PAGE_H_
#include <string>
#include "base/callback.h"
#include "base/macros.h"
#include "base/time/time.h"
#include "chrome/browser/interstitials/security_interstitial_page.h"
#include "chrome/browser/ssl/ssl_cert_reporter.h"
#include "net/ssl/ssl_info.h"
class CertReportHelper;
class GURL;
namespace security_interstitials {
class BadClockUI;
}
// This class is responsible for showing/hiding the interstitial page that
// occurs when an SSL error is triggered by a clock misconfiguration. It
// creates the UI using security_interstitials::BadClockUI and then
// displays it. It deletes itself when the interstitial page is closed.
class BadClockBlockingPage : public SecurityInterstitialPage {
public:
// Interstitial type, used in tests.
static InterstitialPageDelegate::TypeID kTypeForTesting;
// If the blocking page isn't shown, the caller is responsible for cleaning
// up the blocking page. Otherwise, the interstitial takes ownership when
// shown.
BadClockBlockingPage(content::WebContents* web_contents,
int cert_error,
const net::SSLInfo& ssl_info,
const GURL& request_url,
const base::Time& time_triggered,
scoped_ptr<SSLCertReporter> ssl_cert_reporter,
const base::Callback<void(bool)>& callback);
~BadClockBlockingPage() override;
// InterstitialPageDelegate method:
InterstitialPageDelegate::TypeID GetTypeForTesting() const override;
void SetSSLCertReporterForTesting(
scoped_ptr<SSLCertReporter> ssl_cert_reporter);
protected:
// InterstitialPageDelegate implementation:
void CommandReceived(const std::string& command) override;
void OverrideEntry(content::NavigationEntry* entry) override;
void OverrideRendererPrefs(content::RendererPreferences* prefs) override;
void OnDontProceed() override;
// SecurityInterstitialPage implementation:
bool ShouldCreateNewNavigation() const override;
void PopulateInterstitialStrings(
base::DictionaryValue* load_time_data) override;
void AfterShow() override;
private:
void NotifyDenyCertificate();
base::Callback<void(bool)> callback_;
const int cert_error_;
const net::SSLInfo ssl_info_;
const base::Time time_triggered_;
scoped_ptr<ChromeControllerClient> controller_;
scoped_ptr<security_interstitials::BadClockUI> bad_clock_ui_;
scoped_ptr<CertReportHelper> cert_report_helper_;
DISALLOW_COPY_AND_ASSIGN(BadClockBlockingPage);
};
#endif // CHROME_BROWSER_SSL_BAD_CLOCK_BLOCKING_PAGE_H_
| [
"[email protected]"
] | |
ebd553881b77ba5c7e2f451392e109d023e60d3c | 8ea1ba8865a4d8e57e6cf4dc8fdfd1852b59f01e | /DX 12 test engine/Shader.h | da2b642a6e1d1784d86972412fff0c65e4059b3d | [] | no_license | JustinWeq/DX-12-game-engine | 096e408088fc2c4cd5bf7ea2e6dd2762972a5f94 | cbf66e859bfcb81c3f5a879bed7c12c6d195a4d0 | refs/heads/master | 2021-01-22T05:53:49.565204 | 2016-12-19T06:07:50 | 2016-12-19T06:07:50 | 68,679,430 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,132 | h | #pragma once
#include "stdafx.h"
#include "D3DInterface.h"
#include <fstream>
#define PS_5_0 = "ps_5_0"
#define VS_5_0 = "vs_5_0"
// a simple shader class made to lower overhead for custom shaders.
class Shader
{
public:
//defualt shader-- constructs a new instance of Shader with defualt parameters
Shader();
//deconstructor-- cleans up memory for this instance of shader
~Shader();
//initializes the shader
//device- a pointer to the d3dinterface to use for intializtion of the shader
bool Init(D3DInterface* device);
//Cleans up memory for the shader
virtual void Close();
protected:
//returns the input element desc for this shader, this must be overwritten
virtual D3D12_INPUT_ELEMENT_DESC getInputElementLayout() = 0;
//returns the graphics pipeline state description, this is pure virtual so it must be overwritten
//rootSignature- the root signature of the graphics pipeline state object
//inputLayout- the input layout desc for the shader
//device- the d3d interface to use for intialization(a command allocator is executed on the devices queue and the current frame fence value is incremented)
virtual D3D12_GRAPHICS_PIPELINE_STATE_DESC getGraphicsPipelineStateDesc(ID3D12RootSignature* rootSignature, D3D12_INPUT_LAYOUT_DESC inputLayout,
D3DInterface device) = 0;
//loads the shader using the passed in shader file name and target
//shaderFileName- the name of the shader to compile
static bool LoadShader(LPCWSTR shaderFileName, LPCSTR targetType,D3D12_SHADER_BYTECODE* shaderCode);
// pipeline state object for this shader
ID3D12PipelineState* m_pipelineStateObject;
//// the vertex buffer resource in GPU memory
//ID3D12Resource* m_vertexBuffer;
//// a stucture that contains data fot the verticies in gpu memory
//D3D12_VERTEX_BUFFER_VIEW vertexBufferView;
private:
//writes a txt file out to the root directory with shader compiling errors
//shaderErrorMessage- the error message for the failed to compile shader
//shaderFileName- the name of the shader that failed to compile
static void writeShaderErrorLog(ID3DBlob* shaderErrorMessage, LPCWSTR shaderFileName);
};
| [
"JeremyRed@DESKTOP-H6SJ4CP"
] | JeremyRed@DESKTOP-H6SJ4CP |
aa1084e271caf6b23ac2d942cb1c85ccac812f02 | 984b91f28e1d61550ddcb7fcce9448b366a5d405 | /C++ 2016/hw5/Memory.h | 52aa7885b5a5d80508bbd779a7576951c86dd6bc | [] | no_license | rumeysakarakavak/Object-Oriented-Programming | ddc1dc28b6a1c8b42b3b37e319f8fc6dbc258395 | 1b94ba8b849ebee273354ad5a223e1d327f01355 | refs/heads/master | 2023-07-30T13:54:58.219895 | 2021-09-24T12:37:02 | 2021-09-24T12:37:02 | 409,956,255 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,431 | h | /*--------------------------------------------------------------------------*/
/* */
/* HW04_141044063_Rumeysa_Karakavak */
/* */
/* Created on 05/11/2016 by Rumeysa_Karakavak */
/* */
/* Description */
/* ----------- */
/* This file contains header for memory. */
/*--------------------------------------------------------------------------*/
#ifndef HW2_MEMORY_H
#define HW2_MEMORY_H
#include <string>
using namespace std;
// Number of memory.
const int NO_MEMORY = 50;
class Memory {
public:
Memory();
Memory(int option);
int setMem(int memoryNumber, int number) ;
int getMem(int memoryNumber) const;
void printAll() const;
private:
int memories[NO_MEMORY];
};
#endif
/*---------------------------------------------------------------------------*/
/* End of memory.h */
/*---------------------------------------------------------------------------*/
| [
"[email protected]"
] | |
a8a8bf72d934e18c6c44e9509176e7ae3fdf791b | f3349dcf26a056a4d9da5b83212bb2b5edb994da | /quickSort.cpp | 8bca83bfca2151906778ae53e57feafa7a06cbe9 | [] | no_license | islandev/InterViewSum | 0f8f6b28726a610c62ac6380c01495683017f781 | 2c11bc8300eaa9d0645a80f7ebe60bca88b553eb | refs/heads/master | 2020-05-22T14:26:19.333084 | 2014-10-10T17:32:12 | 2014-10-10T17:32:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 317 | cpp | void quickSort(int A[],int l,int h){
if(l>h) return;
int first=l;
int last=h;
int key=a[first];
while(first<last){
while(first<last&&a[last]>=key) --last;
a[first]=a[last];
while(first<last&&a[first]<=key) ++first;
a[last]=a[first];
}
a[first]=key;
quickSort(A,l,first-1);
quickSort(A,last+1,h);
} | [
"[email protected]"
] | |
c18d1d91ef44dca106535f346155fa8ef635e7e6 | 8b8e51e94e61654a3f331b7e4fa6770d1b3dd4d7 | /TnbShipModeler/TnbLib/ShipModeler/Basic/Tools/ShipModeler_Basic_Tools.hxx | 239601590cd1b0fdea51353b02ec7df036d11db6 | [] | no_license | PayvandH/Tonb | 1ea829d6732a3645bbf117a8857af5600e9a5192 | 6964200f033ab0b53fc3f3bfa8d58ca9578ecc66 | refs/heads/master | 2023-01-12T21:24:30.491648 | 2020-11-13T17:12:09 | 2020-11-13T17:12:09 | 312,663,721 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,678 | hxx | #pragma once
#ifndef _ShipModeler_Basic_Tools_Header
#define _ShipModeler_Basic_Tools_Header
#include <Standard_TypeDef.hxx>
#include <memory>
#include <vector>
class TopoDS_Shape;
class gp_Ax2;
namespace tnbLib
{
// Forward Declarations
class Geo_xDistb;
class Marine_CmpSection;
namespace shipModelerLib
{
// Forward declarations
class Basic_Tank;
class Basic_Hull;
class Basic_Sail;
class Basic_WPlane;
class Basic_Tools
{
public:
static std::shared_ptr<Geo_xDistb>
UniformDistribution
(
const TopoDS_Shape& theShape,
const Standard_Integer nbSegments
);
static std::shared_ptr<Geo_xDistb>
UniformDistribution
(
const Standard_Real x0,
const Standard_Real x1,
const Standard_Integer nbSegments
);
static std::shared_ptr<Basic_WPlane>
CreateWorkingPlane
(
const TopoDS_Shape& theShape,
const gp_Ax2& theAx,
const Standard_Real x
);
static std::vector<std::shared_ptr<Basic_WPlane>>
CreateWorkingPlanes
(
const TopoDS_Shape& theShape,
const gp_Ax2& theAx,
const Geo_xDistb& theDistb
);
static std::shared_ptr<Marine_CmpSection> CreateSection(const Basic_WPlane& thePlane);
static std::shared_ptr<Basic_Tank> CreateTank(const std::vector<std::shared_ptr<Basic_WPlane>>& theShape);
static std::shared_ptr<Basic_Sail> CreateSail(const std::vector<std::shared_ptr<Basic_WPlane>>& theShape, const Geo_xDistb& theDistb);
static std::shared_ptr<Basic_Hull> CreateHull(const std::vector<std::shared_ptr<Basic_WPlane>>& theShape, const Geo_xDistb& theDistb);
};
}
}
#endif // !_ShipModeler_Basic_Tools_Header
| [
"[email protected]"
] | |
c91d25b3f10b1955a482012f7a2dea0fd0cb5cb3 | 6f874ccb136d411c8ec7f4faf806a108ffc76837 | /code/Windows-classic-samples/Samples/Win7Samples/multimedia/WindowsAnimation/PriorityComparison/LayoutManager.cpp | 96caebe8410bf3391276d55963a5ef3316d65d37 | [
"MIT"
] | permissive | JetAr/ZDoc | c0f97a8ad8fd1f6a40e687b886f6c25bb89b6435 | e81a3adc354ec33345e9a3303f381dcb1b02c19d | refs/heads/master | 2022-07-26T23:06:12.021611 | 2021-07-11T13:45:57 | 2021-07-11T13:45:57 | 33,112,803 | 8 | 8 | null | null | null | null | UTF-8 | C++ | false | false | 14,526 | cpp | // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved
#include "LayoutManager.h"
#include "UIAnimationSample.h"
const DOUBLE ROW_POSITION = 0.7;
const DOUBLE SELECTED_POSITION = 0.5;
const DOUBLE ACCELERATION_SELECT = 2000.0;
const DOUBLE ACCELERATION_SELECT_AFTER_WAVE = ACCELERATION_SELECT * 0.2;
const DOUBLE ACCELERATION_CENTER = ACCELERATION_SELECT * 0.3;
const UI_ANIMATION_SECONDS PERIOD = 1.0;
const UI_ANIMATION_SECONDS ACCEPTABLE_DELAY_SLIDE = 0.5;
const UI_ANIMATION_SECONDS ACCEPTABLE_DELAY_WAVE = 0.8;
CLayoutManager::CLayoutManager() :
m_pAnimationManager(NULL),
m_pAnimationTimer(NULL),
m_pTransitionLibrary(NULL),
m_uThumbCount(0),
m_thumbs(NULL),
m_iThumbSelected(0),
m_centerX(0.0),
m_rowY(0.0)
{
}
CLayoutManager::~CLayoutManager()
{
// Animation
SafeRelease(&m_pAnimationManager);
SafeRelease(&m_pAnimationTimer);
SafeRelease(&m_pTransitionLibrary);
// Do not delete m_thumbs, as client owns that
}
// Initialization
HRESULT CLayoutManager::Initialize(
IUIAnimationManager *pAnimationManager,
IUIAnimationTimer *pAnimationTimer,
IUIAnimationTransitionLibrary *pTransitionLibrary,
UINT uThumbCount,
CThumbnail *thumbs
)
{
HRESULT hr = S_OK;
m_pAnimationManager = pAnimationManager;
m_pAnimationManager->AddRef();
m_pAnimationTimer = pAnimationTimer;
m_pAnimationTimer->AddRef();
m_pTransitionLibrary = pTransitionLibrary;
m_pTransitionLibrary->AddRef();
// Store a pointer to thumbnail array
m_uThumbCount = uThumbCount;
m_thumbs = thumbs;
return hr;
}
// Re-center the thumbnails when the client area is resized
HRESULT CLayoutManager::Resize(
D2D1_SIZE_F sizeClient
)
{
m_centerX = sizeClient.width * 0.5;
m_rowY = sizeClient.height * ROW_POSITION;
return Arrange();
}
// Arrange the thumbnails and center the selected one
HRESULT CLayoutManager::Arrange()
{
// Center the thumbnails horizontally
HRESULT hr = CenterThumbnails();
if (SUCCEEDED(hr))
{
// Slide the current thumbnail up
hr = SlideThumbnails(
STORYBOARD_ID_NONE,
ACCELERATION_SELECT,
0.0,
m_iThumbSelected,
SLIDE_INDEX_NONE
);
if (SUCCEEDED(hr))
{
// Center all the other thumbnails vertically
IUIAnimationStoryboard *pStoryboard;
hr = m_pAnimationManager->CreateStoryboard(
&pStoryboard
);
if (SUCCEEDED(hr))
{
for (UINT i = 0; i < m_uThumbCount; i++)
{
if (i != m_iThumbSelected)
{
IUIAnimationTransition *pTransitionYCenter;
hr = m_pTransitionLibrary->CreateParabolicTransitionFromAcceleration(
m_rowY,
0.0,
ACCELERATION_SELECT,
&pTransitionYCenter
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransition(
m_thumbs[i].m_pAnimationVariableY,
pTransitionYCenter
);
pTransitionYCenter->Release();
}
if (FAILED(hr))
{
break;
}
}
}
// Don't tag the Storyboard for priority comparison
if (SUCCEEDED(hr))
{
hr = ScheduleStoryboard(pStoryboard);
}
pStoryboard->Release();
}
}
}
return hr;
}
// Selects the next thumbnail in the array and slides it up
HRESULT CLayoutManager::Next()
{
HRESULT hr = S_OK;
if (m_iThumbSelected < m_uThumbCount - 1)
{
hr = SlideThumbnails(
STORYBOARD_ID_SLIDE,
ACCELERATION_SELECT,
ACCEPTABLE_DELAY_SLIDE,
m_iThumbSelected + 1,
m_iThumbSelected
);
if (SUCCEEDED(hr))
{
m_iThumbSelected++;
hr = CenterThumbnails();
}
}
return hr;
}
// Selects the previous thumbnail in the array and slides it up
HRESULT CLayoutManager::Previous()
{
HRESULT hr = S_OK;
if (m_iThumbSelected > 0)
{
hr = SlideThumbnails(
STORYBOARD_ID_SLIDE,
ACCELERATION_SELECT,
ACCEPTABLE_DELAY_SLIDE,
m_iThumbSelected - 1,
m_iThumbSelected
);
if (SUCCEEDED(hr))
{
m_iThumbSelected--;
hr = CenterThumbnails();
}
}
return hr;
}
// Creates a sinusoidal wave through the array of thumbnails
HRESULT CLayoutManager::Wave(
UI_ANIMATION_SLOPE slope
)
{
const DOUBLE AMPLITUDE = 200.0;
const UI_ANIMATION_SECONDS SECONDS_BETWEEN_THUMBS = 0.03;
// First make sure the the thumbnails are down
HRESULT hr = SlideThumbnails(
STORYBOARD_ID_WAVE,
ACCELERATION_SELECT,
ACCEPTABLE_DELAY_WAVE,
SLIDE_INDEX_NONE,
m_iThumbSelected
);
if (SUCCEEDED(hr))
{
// Build a storyboard to animate all thumbnails vertically in a wave pattern
IUIAnimationStoryboard *pStoryboard;
hr = m_pAnimationManager->CreateStoryboard(
&pStoryboard
);
if (SUCCEEDED(hr))
{
for (UINT i = 0; i < m_uThumbCount; i++)
{
// Use keyframes to offset each thumbnail's animation a little more from the start than its predecessor
UI_ANIMATION_KEYFRAME keyframe;
hr = pStoryboard->AddKeyframeAtOffset(
UI_ANIMATION_KEYFRAME_STORYBOARD_START,
SECONDS_BETWEEN_THUMBS * i,
&keyframe
);
if (SUCCEEDED(hr))
{
IUIAnimationTransition *pTransitionYSinusoidal;
hr = m_pTransitionLibrary->CreateSinusoidalTransitionFromRange(
PERIOD,
m_rowY - AMPLITUDE,
m_rowY + AMPLITUDE,
PERIOD,
slope,
&pTransitionYSinusoidal
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransitionAtKeyframe(
m_thumbs[i].m_pAnimationVariableY,
pTransitionYSinusoidal,
keyframe
);
pTransitionYSinusoidal->Release();
if (SUCCEEDED(hr))
{
// Add a zero-duration constant transition to bring the velocity to zero
IUIAnimationTransition* pTransitionYConstant;
hr = m_pTransitionLibrary->CreateConstantTransition(
0.0,
&pTransitionYConstant
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransition(
m_thumbs[i].m_pAnimationVariableY,
pTransitionYConstant
);
pTransitionYConstant->Release();
}
}
}
}
if (FAILED(hr))
{
break;
}
}
if (SUCCEEDED(hr))
{
// Tag the storyboard for priority comparison
hr = pStoryboard->SetTag(
NULL,
STORYBOARD_ID_WAVE
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->SetLongestAcceptableDelay(
UI_ANIMATION_SECONDS_EVENTUALLY
);
if (SUCCEEDED(hr))
{
hr = ScheduleStoryboard(pStoryboard);
if (SUCCEEDED(hr))
{
// Slide the selected thumbnail back up
hr = SlideThumbnails(
STORYBOARD_ID_SLIDE_AFTER_WAVE,
ACCELERATION_SELECT_AFTER_WAVE,
UI_ANIMATION_SECONDS_EVENTUALLY,
m_iThumbSelected,
SLIDE_INDEX_NONE
);
}
}
}
}
pStoryboard->Release();
}
}
return hr;
}
// Moves the selected image horizontally to the center of the client area
HRESULT CLayoutManager::CenterThumbnails()
{
const DOUBLE THUMB_SPACING = 60.0;
IUIAnimationStoryboard *pStoryboard;
HRESULT hr = m_pAnimationManager->CreateStoryboard(
&pStoryboard
);
if (SUCCEEDED(hr))
{
for (UINT i = 0; i < m_uThumbCount; i++)
{
D2D1_SIZE_F size = m_thumbs[i].GetSize();
IUIAnimationTransition *pTransitionX;
hr = m_pTransitionLibrary->CreateParabolicTransitionFromAcceleration(
m_centerX + ((static_cast<INT32>(i) - static_cast<INT32>(m_iThumbSelected)) * THUMB_SPACING),
0.0,
ACCELERATION_CENTER,
&pTransitionX
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransition(
m_thumbs[i].m_pAnimationVariableX,
pTransitionX
);
pTransitionX->Release();
}
if (FAILED(hr))
{
break;
}
}
// Don't tag the storyboard for priority comparison
if (SUCCEEDED(hr))
{
hr = ScheduleStoryboard(pStoryboard);
}
pStoryboard->Release();
}
return hr;
}
// Slides one thumbnail up and/or another thumbnail down
// SLIDE_INDEX_NONE can be passed for slideUpIndex or slideDownIndex
HRESULT CLayoutManager::SlideThumbnails(
STORYBOARD_ID storyboardId,
DOUBLE acceleration,
UI_ANIMATION_SECONDS secondsLongestAcceptableDelay,
UINT slideUpIndex,
UINT slideDownIndex
)
{
DOUBLE selectedY = m_rowY * SELECTED_POSITION;
IUIAnimationStoryboard *pStoryboard;
HRESULT hr = m_pAnimationManager->CreateStoryboard(
&pStoryboard
);
if (SUCCEEDED(hr))
{
if (slideUpIndex != SLIDE_INDEX_NONE)
{
D2D1_SIZE_F size = m_thumbs[slideUpIndex].GetSize();
IUIAnimationTransition *pTransitionYUp;
hr = m_pTransitionLibrary->CreateParabolicTransitionFromAcceleration(
selectedY,
0.0,
acceleration,
&pTransitionYUp
);
if (SUCCEEDED(hr))
{
hr = pTransitionYUp->SetInitialVelocity(
0.0
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransition(
m_thumbs[slideUpIndex].m_pAnimationVariableY,
pTransitionYUp
);
}
pTransitionYUp->Release();
}
}
if (SUCCEEDED(hr))
{
if (slideDownIndex != SLIDE_INDEX_NONE)
{
IUIAnimationTransition *pTransitionYDown;
hr = m_pTransitionLibrary->CreateParabolicTransitionFromAcceleration(
m_rowY,
0.0,
acceleration,
&pTransitionYDown
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->AddTransition(
m_thumbs[slideDownIndex].m_pAnimationVariableY,
pTransitionYDown
);
pTransitionYDown->Release();
}
}
if (SUCCEEDED(hr))
{
// Tag the storyboard for priority comparison
hr = pStoryboard->SetTag(
NULL,
storyboardId
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->SetLongestAcceptableDelay(
secondsLongestAcceptableDelay
);
if (SUCCEEDED(hr))
{
hr = ScheduleStoryboard(pStoryboard);
}
}
}
}
pStoryboard->Release();
}
return hr;
}
// Gets the current time and schedules a storyboard for play
HRESULT CLayoutManager::ScheduleStoryboard(
IUIAnimationStoryboard *pStoryboard
)
{
UI_ANIMATION_SECONDS secondsNow;
HRESULT hr = m_pAnimationTimer->GetTime(
&secondsNow
);
if (SUCCEEDED(hr))
{
hr = pStoryboard->Schedule(
secondsNow
);
}
return hr;
}
| [
"[email protected]"
] | |
901692c67bbbbd4e394537c9e48b265758290366 | 5a770d60733315f1183cb550c28bb8a6f4b347e1 | /ui/system_set.cpp | 374503a99c9c4c17889ee00138e88e64b9fd031c | [
"Apache-2.0"
] | permissive | joke-lab/project | 1712249c24f8bf8418ae1e9815963a9b63df9da9 | ef5984d9ec0ad61b76b85f21c9ffc58fb99c94c9 | refs/heads/main | 2023-07-23T01:32:57.219480 | 2021-09-02T01:44:09 | 2021-09-02T01:44:09 | 402,252,834 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,875 | cpp | #include "system_set.h"
#include "ui_system_set.h"
system_set::system_set(QWidget *parent) :
QWidget(parent),
ui(new Ui::system_set)
{
ui->setupUi(this);
setAttribute(Qt::WA_QuitOnClose,false);
ini_set(); //站点信息设置函数的调用
QObject::connect(ui->confirm,SIGNAL(clicked(bool)),this,SLOT(confirmSlot())); //确认按钮的槽函数的连接
QObject::connect(ui->cancel,SIGNAL(clicked(bool)),this,SLOT(cancelSlot())); //取消按钮的槽函数的连接
}
//设置界面初始信息的读出与设置
void system_set::ini_set()
{
QSettings *ini = new QSettings(QCoreApplication::applicationDirPath()+"/setting.ini",QSettings::IniFormat);
ui->Lineedit1->setText(ini->value("/site_information/name").toString());
ui->Lineedit2->setText(ini->value("/site_information/englishabbr").toString());
ui->Lineedit3->setText(ini->value("/site_information/sitenumber").toString());
if(ini->value("/site_information/shoreBased").toInt())
ui->check1->setChecked(true);
else if(ini->value("/site_information/onBoard").toInt())
ui->check2->setChecked(true);
ui->radar_correction_angle->setText(ini->value("/calculation_parameter/radar_correction_angle").toString());
ui->water_depth->setText(ini->value("/calculation_parameter/water_depth").toString());
//ui->ship_high->setText(ini->value("/calculation_parameter/ship_high").toString());
ui->time_domain_points->setText(ini->value("/calculation_parameter/time_domain_points").toString());
ui->airspace_points_x->setText(ini->value("/calculation_parameter/airspace_points_x").toString());
ui->airspace_points_y->setText(ini->value("/calculation_parameter/airspace_points_y").toString());
ui->sampling_interval_time->setText(ini->value("/calculation_parameter/sampling_interval_time").toString());
ui->sampling_interval_x->setText(ini->value("/calculation_parameter/sampling_interval_x").toString());
ui->sampling_interval_y->setText(ini->value("/calculation_parameter/sampling_interval_y").toString());
ui->edit1->setText(ini->value("/radar_information/minimum").toString());
ui->edit2->setText(ini->value("/radar_information/maximum").toString());
ui->combo->setCurrentText(ini->value("/radar_information/samplestep").toString());
ui->edit4->setText(ini->value("/radar_information/noisebasevalue").toString());
ui->edit5->setText(ini->value("/radar_information/triggerdelay").toString()); //触发延时
ui->edit6->setText(ini->value("/radar_information/openglAngle").toString());
ui->gatestep->setText(ini->value("/radar_information/gatestep").toString());
ui->grade->setText(ini->value("/radar_information/grade").toString());
ui->AsynDisturb->setChecked(ini->value("/radar_information/state").toBool());
qDebug() << "初始信息调用" <<ui->grade;
}
//确认按钮的槽函数
//将此时界面上设置的参数全部存入初始文件中
void system_set::confirmSlot()
{
if(!global::transceiver_turnon_bool)
{
QSettings *ini = new QSettings(QCoreApplication::applicationDirPath()+"/setting.ini",QSettings::IniFormat);
ini->setValue("/site_information/name",ui->Lineedit1->text());
ini->setValue("/site_information/englishabbr",ui->Lineedit2->text());
ini->setValue("/site_information/sitenumber",ui->Lineedit3->text());
ini->setValue("/calculation_parameter/radar_correction_angle",ui->radar_correction_angle->text());
ini->setValue("/calculation_parameter/water_depth",ui->water_depth->text());
ini->setValue("/calculation_parameter/time_domain_points",ui->time_domain_points->text());
ini->setValue("/calculation_parameter/airspace_points_x",ui->airspace_points_x->text());
ini->setValue("/calculation_parameter/airspace_points_y",ui->airspace_points_y->text());
ini->setValue("/calculation_parameter/sampling_interval_time",ui->sampling_interval_time->text());
ini->setValue("/calculation_parameter/sampling_interval_x",ui->sampling_interval_x->text());
ini->setValue("/calculation_parameter/sampling_interval_y",ui->sampling_interval_y->text());
ini->setValue("/radar_information/samplestep",ui->combo->currentText());
ini->setValue("/radar_information/minimum",ui->edit1->text()); //采样开始距离
ini->setValue("/radar_information/maximum",ui->edit2->text()); //采样结束距离
ini->setValue("/radar_information/noisebasevalue",ui->edit4->text()); //噪声基底
ini->setValue("/radar_information/triggerdelay",ui->edit5->text()); //触发延时
ini->setValue("/radar_information/openglAngle",ui->edit6->text());
ini->setValue("/radar_information/gatestep",ui->gatestep->text());
ini->setValue("/radar_information/grade",ui->grade->text());
int dsamplestart = ini->value("/radar_information/minimum").toInt();
int dsampleend = ini->value("/radar_information/maximum").toInt();
int triggerdelay = ini->value("/radar_information/triggerdelay").toInt();
//int samplestart = dsamplestart* 3e8 * (1.0/120000000)/2 - triggerdelay + 0.5;
//int sampleend = dsampleend* 3e8 * (1.0/120000000)/2 - triggerdelay + 0.5;
int startpoint = dsamplestart + triggerdelay; //计算触发延时之后起始点数
int endpoint = dsampleend + triggerdelay; //计算触发延时之后结束点数
ini->setValue("/radar_information/startpoint",startpoint);
ini->setValue("/radar_information/endpoint",endpoint);
if(ui->check1->isChecked())
{
ini->setValue("/site_information/shoreBased",1);
ini->setValue("/site_information/onBoard",0);
}
else if (ui->check2->isChecked())
{
ini->setValue("/site_information/shoreBased",0);
ini->setValue("/site_information/onBoard",1);
}
//反异步干扰判断
if(ui->AsynDisturb->isChecked())
{
ini->setValue("/radar_information/state",1);//反异步干扰开启
}
else
{
ini->setValue("/radar_information/state",0);//反异步干扰关闭
}
emit update_radarinform(); //发往主界面，采样起始结束距离和采样步长
//emit update_//改变反异步干扰状态
this->close();
qDebug() << "调用一次";
}
else if(global::transceiver_turnon_bool)
{
//QMessageBox::warning(nullptr,"无法更改系统设置","请先关闭发射机，再更改系统参数！",QMessageBox::Ok,1);
}
}
//取消按钮的槽函数
void system_set::cancelSlot()
{
this->close();
}
system_set::~system_set()
{
delete ui;
}
| [
"[email protected]"
] | |
a1a865030b11cd1b3c2b489d1376d5951a0eed78 | d27ca729b15e4bd20d468d36972ba55000db9371 | /src/hash.h | 4e990a92eb0d844221391e93f3cea95286f6381f | [
"MIT"
] | permissive | cognitio-project/cognitio | 2a2488884ea54148948da3b621fb73bde415674a | 722123667b5d44715b22f780ff5ee402ab884b16 | refs/heads/master | 2020-03-07T02:24:47.278247 | 2018-03-28T01:41:14 | 2018-03-28T01:41:14 | 127,208,444 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,012 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Copyright (c) 2017-2018 The Cognitio developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef XEVAN_H
#define XEVAN_H
#include "crypto/ripemd160.h"
#include "crypto/sha256.h"
#include "prevector.h"
#include "serialize.h"
#include "uint256.h"
#include "version.h"
#include "crypto/sph_blake.h"
#include "crypto/sph_bmw.h"
#include "crypto/sph_groestl.h"
#include "crypto/sph_jh.h"
#include "crypto/sph_keccak.h"
#include "crypto/sph_skein.h"
#include "crypto/sph_luffa.h"
#include "crypto/sph_cubehash.h"
#include "crypto/sph_shavite.h"
#include "crypto/sph_simd.h"
#include "crypto/sph_echo.h"
#include "crypto/sph_hamsi.h"
#include "crypto/sph_fugue.h"
#include "crypto/sph_shabal.h"
#include "crypto/sph_whirlpool.h"
#include "crypto/sph_sha2.h"
#include "crypto/sph_haval.h"
#include <iomanip>
#include <openssl/sha.h>
#include <sstream>
#include <vector>
using namespace std;
typedef uint256 ChainCode;
#ifdef GLOBALDEFINED
#define GLOBAL
#else
#define GLOBAL extern
#endif
GLOBAL sph_blake512_context z_blake;
GLOBAL sph_bmw512_context z_bmw;
GLOBAL sph_groestl512_context z_groestl;
GLOBAL sph_jh512_context z_jh;
GLOBAL sph_keccak512_context z_keccak;
GLOBAL sph_skein512_context z_skein;
GLOBAL sph_luffa512_context z_luffa;
GLOBAL sph_cubehash512_context z_cubehash;
GLOBAL sph_shavite512_context z_shavite;
GLOBAL sph_simd512_context z_simd;
GLOBAL sph_echo512_context z_echo;
GLOBAL sph_hamsi512_context z_hamsi;
GLOBAL sph_fugue512_context z_fugue;
GLOBAL sph_shabal512_context z_shabal;
GLOBAL sph_whirlpool_context z_whirlpool;
GLOBAL sph_sha512_context z_sha2;
GLOBAL sph_haval256_5_context z_haval;
#define fillz() do { \
sph_blake512_init(&z_blake); \
sph_bmw512_init(&z_bmw); \
sph_groestl512_init(&z_groestl); \
sph_jh512_init(&z_jh); \
sph_keccak512_init(&z_keccak); \
sph_skein512_init(&z_skein); \
sph_luffa512_init(&z_luffa); \
sph_cubehash512_init(&z_cubehash); \
sph_shavite512_init(&z_shavite); \
sph_simd512_init(&z_simd); \
sph_echo512_init(&z_echo); \
sph_hamsi512_init(&z_hamsi); \
sph_fugue512_init(&z_fugue); \
sph_shabal512_init(&z_shabal); \
sph_whirlpool_init(&z_whirlpool); \
sph_sha512_init(&z_sha2); \
sph_haval256_5_init(&z_haval); \
} while (0)
#define ZBLAKE (memcpy(&ctx_blake, &z_blake, sizeof(z_blake)))
#define ZBMW (memcpy(&ctx_bmw, &z_bmw, sizeof(z_bmw)))
#define ZGROESTL (memcpy(&ctx_groestl, &z_groestl, sizeof(z_groestl)))
#define ZJH (memcpy(&ctx_jh, &z_jh, sizeof(z_jh)))
#define ZKECCAK (memcpy(&ctx_keccak, &z_keccak, sizeof(z_keccak)))
#define ZSKEIN (memcpy(&ctx_skein, &z_skein, sizeof(z_skein)))
#define ZHAMSI (memcpy(&ctx_hamsi, &z_hamsi, sizeof(z_hamsi)))
#define ZFUGUE (memcpy(&ctx_fugue, &z_fugue, sizeof(z_fugue)))
#define ZSHABAL (memcpy(&ctx_shabal, &z_shabal, sizeof(z_shabal)))
#define ZWHIRLPOOL (memcpy(&ctx_whirlpool, &z_whirlpool, sizeof(z_whirlpool)))
#define ZSHA2 (memcpy(&ctx_sha2, &z_sha2, sizeof(z_sha2)))
#define ZHAVAL (memcpy(&ctx_haval, &z_haval, sizeof(z_haval)))
/** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
class CHash256
{
private:
CSHA256 sha;
public:
static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
void Finalize(unsigned char hash[OUTPUT_SIZE])
{
unsigned char buf[sha.OUTPUT_SIZE];
sha.Finalize(buf);
sha.Reset().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
}
CHash256& Write(const unsigned char* data, size_t len)
{
sha.Write(data, len);
return *this;
}
CHash256& Reset()
{
sha.Reset();
return *this;
}
};
/** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
class CHash160
{
private:
CSHA256 sha;
public:
static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
void Finalize(unsigned char hash[OUTPUT_SIZE])
{
unsigned char buf[sha.OUTPUT_SIZE];
sha.Finalize(buf);
CRIPEMD160().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
}
CHash160& Write(const unsigned char* data, size_t len)
{
sha.Write(data, len);
return *this;
}
CHash160& Reset()
{
sha.Reset();
return *this;
}
};
inline void Hash(void* in, unsigned int len, unsigned char* out)
{
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, in, len);
SHA256_Final(out, &sha256);
}
/** Compute the 256-bit hash of an object. */
template <typename T1>
inline uint256 Hash(const T1 pbegin, const T1 pend)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 256-bit hash of the concatenation of two objects. */
template <typename T1, typename T2>
inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 256-bit hash of the concatenation of three objects. */
template <typename T1, typename T2, typename T3>
inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 256-bit hash of the concatenation of three objects. */
template <typename T1, typename T2, typename T3, typename T4>
inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 256-bit hash of the concatenation of three objects. */
template <typename T1, typename T2, typename T3, typename T4, typename T5>
inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end, const T5 p5begin, const T5 p5end)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 256-bit hash of the concatenation of three objects. */
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end, const T5 p5begin, const T5 p5end, const T6 p6begin, const T6 p6end)
{
static const unsigned char pblank[1] = {};
uint256 result;
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0])).Write(p6begin == p6end ? pblank : (const unsigned char*)&p6begin[0], (p6end - p6begin) * sizeof(p6begin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 160-bit hash an object. */
template <typename T1>
inline uint160 Hash160(const T1 pbegin, const T1 pend)
{
static unsigned char pblank[1] = {};
uint160 result;
CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
return result;
}
/** Compute the 160-bit hash of a vector. */
inline uint160 Hash160(const std::vector<unsigned char>& vch)
{
return Hash160(vch.begin(), vch.end());
}
/** A writer stream (for serialization) that computes a 256-bit hash. */
class CHashWriter
{
private:
CHash256 ctx;
public:
int nType;
int nVersion;
CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
CHashWriter& write(const char* pch, size_t size)
{
ctx.Write((const unsigned char*)pch, size);
return (*this);
}
// invalidates the object
uint256 GetHash()
{
uint256 result;
ctx.Finalize((unsigned char*)&result);
return result;
}
template <typename T>
CHashWriter& operator<<(const T& obj)
{
// Serialize to this stream
::Serialize(*this, obj, nType, nVersion);
return (*this);
}
};
/** Compute the 256-bit hash of an object's serialization. */
template <typename T>
uint256 SerializeHash(const T& obj, int nType = SER_GETHASH, int nVersion = PROTOCOL_VERSION)
{
CHashWriter ss(nType, nVersion);
ss << obj;
return ss.GetHash();
}
unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
void BIP32Hash(const unsigned char chainCode[32], unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
//int HMAC_SHA512_Init(HMAC_SHA512_CTX *pctx, const void *pkey, size_t len);
//int HMAC_SHA512_Update(HMAC_SHA512_CTX *pctx, const void *pdata, size_t len);
//int HMAC_SHA512_Final(unsigned char *pmd, HMAC_SHA512_CTX *pctx);
template<typename T1>
inline uint256 XEVAN(const T1 pbegin, const T1 pend)
{
//LogPrintf("X11 Hash \n");
sph_blake512_context ctx_blake;
sph_bmw512_context ctx_bmw;
sph_groestl512_context ctx_groestl;
sph_jh512_context ctx_jh;
sph_keccak512_context ctx_keccak;
sph_skein512_context ctx_skein;
sph_luffa512_context ctx_luffa;
sph_cubehash512_context ctx_cubehash;
sph_shavite512_context ctx_shavite;
sph_simd512_context ctx_simd;
sph_echo512_context ctx_echo;
sph_hamsi512_context ctx_hamsi;
sph_fugue512_context ctx_fugue;
sph_shabal512_context ctx_shabal;
sph_whirlpool_context ctx_whirlpool;
sph_sha512_context ctx_sha2;
sph_haval256_5_context ctx_haval;
static unsigned char pblank[1];
#ifndef QT_NO_DEBUG
//std::string strhash;
//strhash = "";
#endif
int worknumber =128;
uint512 hash[34];
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, (pbegin == pend ? pblank : static_cast<const void*>(&pbegin[0])), (pend - pbegin) * sizeof(pbegin[0]));
sph_blake512_close(&ctx_blake, static_cast<void*>(&hash[0]));
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, static_cast<const void*>(&hash[0]), worknumber);
sph_bmw512_close(&ctx_bmw, static_cast<void*>(&hash[1]));
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl, static_cast<const void*>(&hash[1]), worknumber);
sph_groestl512_close(&ctx_groestl, static_cast<void*>(&hash[2]));
sph_skein512_init(&ctx_skein);
sph_skein512 (&ctx_skein, static_cast<const void*>(&hash[2]), worknumber);
sph_skein512_close(&ctx_skein, static_cast<void*>(&hash[3]));
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, static_cast<const void*>(&hash[3]), worknumber);
sph_jh512_close(&ctx_jh, static_cast<void*>(&hash[4]));
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, static_cast<const void*>(&hash[4]), worknumber);
sph_keccak512_close(&ctx_keccak, static_cast<void*>(&hash[5]));
sph_luffa512_init(&ctx_luffa);
sph_luffa512 (&ctx_luffa, static_cast<void*>(&hash[5]), worknumber);
sph_luffa512_close(&ctx_luffa, static_cast<void*>(&hash[6]));
sph_cubehash512_init(&ctx_cubehash);
sph_cubehash512 (&ctx_cubehash, static_cast<const void*>(&hash[6]), worknumber);
sph_cubehash512_close(&ctx_cubehash, static_cast<void*>(&hash[7]));
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, static_cast<const void*>(&hash[7]), worknumber);
sph_shavite512_close(&ctx_shavite, static_cast<void*>(&hash[8]));
sph_simd512_init(&ctx_simd);
sph_simd512 (&ctx_simd, static_cast<const void*>(&hash[8]), worknumber);
sph_simd512_close(&ctx_simd, static_cast<void*>(&hash[9]));
sph_echo512_init(&ctx_echo);
sph_echo512 (&ctx_echo, static_cast<const void*>(&hash[9]), worknumber);
sph_echo512_close(&ctx_echo, static_cast<void*>(&hash[10]));
sph_hamsi512_init(&ctx_hamsi);
sph_hamsi512 (&ctx_hamsi, static_cast<const void*>(&hash[10]), worknumber);
sph_hamsi512_close(&ctx_hamsi, static_cast<void*>(&hash[11]));
sph_fugue512_init(&ctx_fugue);
sph_fugue512 (&ctx_fugue, static_cast<const void*>(&hash[11]), worknumber);
sph_fugue512_close(&ctx_fugue, static_cast<void*>(&hash[12]));
sph_shabal512_init(&ctx_shabal);
sph_shabal512 (&ctx_shabal, static_cast<const void*>(&hash[12]), worknumber);
sph_shabal512_close(&ctx_shabal, static_cast<void*>(&hash[13]));
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, static_cast<const void*>(&hash[13]), worknumber);
sph_whirlpool_close(&ctx_whirlpool, static_cast<void*>(&hash[14]));
sph_sha512_init(&ctx_sha2);
sph_sha512 (&ctx_sha2, static_cast<const void*>(&hash[14]), worknumber);
sph_sha512_close(&ctx_sha2, static_cast<void*>(&hash[15]));
sph_haval256_5_init(&ctx_haval);
sph_haval256_5 (&ctx_haval, static_cast<const void*>(&hash[15]), worknumber);
sph_haval256_5_close(&ctx_haval, static_cast<void*>(&hash[16]));
/// Part2
sph_blake512_init(&ctx_blake);
sph_blake512 (&ctx_blake, static_cast<const void*>(&hash[16]), worknumber);
sph_blake512_close(&ctx_blake, static_cast<void*>(&hash[17]));
sph_bmw512_init(&ctx_bmw);
sph_bmw512 (&ctx_bmw, static_cast<const void*>(&hash[17]), worknumber);
sph_bmw512_close(&ctx_bmw, static_cast<void*>(&hash[18]));
sph_groestl512_init(&ctx_groestl);
sph_groestl512 (&ctx_groestl, static_cast<const void*>(&hash[18]), worknumber);
sph_groestl512_close(&ctx_groestl, static_cast<void*>(&hash[19]));
sph_skein512_init(&ctx_skein);
sph_skein512 (&ctx_skein, static_cast<const void*>(&hash[19]), worknumber);
sph_skein512_close(&ctx_skein, static_cast<void*>(&hash[20]));
sph_jh512_init(&ctx_jh);
sph_jh512 (&ctx_jh, static_cast<const void*>(&hash[20]), worknumber);
sph_jh512_close(&ctx_jh, static_cast<void*>(&hash[21]));
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, static_cast<const void*>(&hash[21]), worknumber);
sph_keccak512_close(&ctx_keccak, static_cast<void*>(&hash[22]));
sph_luffa512_init(&ctx_luffa);
sph_luffa512 (&ctx_luffa, static_cast<void*>(&hash[22]), worknumber);
sph_luffa512_close(&ctx_luffa, static_cast<void*>(&hash[23]));
sph_cubehash512_init(&ctx_cubehash);
sph_cubehash512 (&ctx_cubehash, static_cast<const void*>(&hash[23]), worknumber);
sph_cubehash512_close(&ctx_cubehash, static_cast<void*>(&hash[24]));
sph_shavite512_init(&ctx_shavite);
sph_shavite512(&ctx_shavite, static_cast<const void*>(&hash[24]), worknumber);
sph_shavite512_close(&ctx_shavite, static_cast<void*>(&hash[25]));
sph_simd512_init(&ctx_simd);
sph_simd512 (&ctx_simd, static_cast<const void*>(&hash[25]), worknumber);
sph_simd512_close(&ctx_simd, static_cast<void*>(&hash[26]));
sph_echo512_init(&ctx_echo);
sph_echo512 (&ctx_echo, static_cast<const void*>(&hash[26]), worknumber);
sph_echo512_close(&ctx_echo, static_cast<void*>(&hash[27]));
sph_hamsi512_init(&ctx_hamsi);
sph_hamsi512 (&ctx_hamsi, static_cast<const void*>(&hash[27]), worknumber);
sph_hamsi512_close(&ctx_hamsi, static_cast<void*>(&hash[28]));
sph_fugue512_init(&ctx_fugue);
sph_fugue512 (&ctx_fugue, static_cast<const void*>(&hash[28]), worknumber);
sph_fugue512_close(&ctx_fugue, static_cast<void*>(&hash[29]));
sph_shabal512_init(&ctx_shabal);
sph_shabal512 (&ctx_shabal, static_cast<const void*>(&hash[29]), worknumber);
sph_shabal512_close(&ctx_shabal, static_cast<void*>(&hash[30]));
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, static_cast<const void*>(&hash[30]), worknumber);
sph_whirlpool_close(&ctx_whirlpool, static_cast<void*>(&hash[31]));
sph_sha512_init(&ctx_sha2);
sph_sha512 (&ctx_sha2, static_cast<const void*>(&hash[31]), worknumber);
sph_sha512_close(&ctx_sha2, static_cast<void*>(&hash[32]));
sph_haval256_5_init(&ctx_haval);
sph_haval256_5 (&ctx_haval, static_cast<const void*>(&hash[32]), worknumber);
sph_haval256_5_close(&ctx_haval, static_cast<void*>(&hash[33]));
return hash[33].trim256();
}
void scrypt_hash(const char* pass, unsigned int pLen, const char* salt, unsigned int sLen, char* output, unsigned int N, unsigned int r, unsigned int p, unsigned int dkLen);
#endif // BITCOIN_HASH_H
| [
"[email protected]"
] | |
252167678bdf100cb0ce7cad1f987a687a3b5b30 | 911a03f76ba5313d66617acfe2b4ca0a0b89dff5 | /m8pushbox/M8PushBoxCell.cpp | 112b5ba14af8096882c245b3e1d0ff4718e8b256 | [] | no_license | houyhea/M8-PushBox | 60a8e50f8f152c2e310000c8caee1cd18b16ee11 | 664f085bc12d880804c30ba05850a61e6cbfcdd4 | refs/heads/master | 2021-01-01T17:41:59.636918 | 2014-08-10T03:51:30 | 2014-08-10T03:51:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 109 | cpp | #include "M8PushBoxCell.h"
M8PushBoxCell::M8PushBoxCell(void)
{
}
M8PushBoxCell::~M8PushBoxCell(void)
{
}
| [
"[email protected]"
] | |
eaffa5e2d03461114cd360e9407d7821093a7a0a | 79027f27e14a0f42761727cda168959625de35d0 | /ogldev-source/Common/pipeline.cpp | ae24ae7350e6eefc6f63407aefd2b08dbe960c9b | [] | no_license | supertomatoXX/opengl | 137b5eb276c7e0812106d30463b67cc3a87fac20 | 1c15ae3daadfaa572801eadb73dff72533474eb1 | refs/heads/master | 2021-04-12T09:29:05.265050 | 2018-06-04T02:29:23 | 2018-06-04T02:29:23 | 126,462,163 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,191 | cpp | /*
Copyright 2010 Etay Meiri
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ogldev_pipeline.h"
const Matrix4f& Pipeline::GetProjTrans()
{
m_ProjTransformation.InitPersProjTransform(m_persProjInfo);
return m_ProjTransformation;
}
const Matrix4f& Pipeline::GetVPTrans()
{
GetViewTrans();
GetProjTrans();
m_VPtransformation = m_ProjTransformation * m_Vtransformation;
return m_VPtransformation;
}
const Matrix4f& Pipeline::GetWorldTrans()
{
Matrix4f ScaleTrans, RotateTrans, TranslationTrans;
ScaleTrans.InitScaleTransform(m_scale.x, m_scale.y, m_scale.z);
RotateTrans.InitRotateTransform(m_rotateInfo.x, m_rotateInfo.y, m_rotateInfo.z);
TranslationTrans.InitTranslationTransform(m_worldPos.x, m_worldPos.y, m_worldPos.z);
m_Wtransformation = TranslationTrans * RotateTrans * ScaleTrans;
return m_Wtransformation;
}
const Matrix4f& Pipeline::GetViewTrans()
{
Matrix4f CameraTranslationTrans, CameraRotateTrans;
//M1*V1 = M2 * V2 v2 = M2(-1)*M1*V1 M1 = E V2 = M2(-1)*V1 正交变货 V2=M2(T)*V1
//E*V1 = TR*V2 V2 = (TR)(-1)*V1 V2 = R(-1)*T(-1)*V1 = R(T)*T(-1)*V1
//T(-1) -Tx -Ty -Tz
//R(T) 行运算 还是 列运算
CameraTranslationTrans.InitTranslationTransform(-m_camera.Pos.x, -m_camera.Pos.y, -m_camera.Pos.z);
//列储存，转置成行储存
//ux uy uz 0 1 0 0 -Tx ux uy uz -U*T
//vx vy vz 0 * 0 1 0 -Ty = vx vy vz -V*T
//nx ny nz 0 0 0 1 -Tz nx ny nz -N*T
//0 0 0 1 0 0 0 1 0 0 0 1
CameraRotateTrans.InitCameraTransform(m_camera.Target, m_camera.Up);
m_Vtransformation = CameraRotateTrans * CameraTranslationTrans;
return m_Vtransformation;
}
const Matrix4f& Pipeline::GetWVPTrans()
{
GetWorldTrans();
GetVPTrans();
m_WVPtransformation = m_VPtransformation * m_Wtransformation;
return m_WVPtransformation;
}
const Matrix4f& Pipeline::GetWVOrthoPTrans()
{
GetWorldTrans();
GetViewTrans();
Matrix4f P;
P.InitOrthoProjTransform(m_orthoProjInfo);
m_WVPtransformation = P * m_Vtransformation * m_Wtransformation;
return m_WVPtransformation;
}
const Matrix4f& Pipeline::GetWVTrans()
{
GetWorldTrans();
GetViewTrans();
m_WVtransformation = m_Vtransformation * m_Wtransformation;
return m_WVtransformation;
}
const Matrix4f& Pipeline::GetWPTrans()
{
Matrix4f PersProjTrans;
GetWorldTrans();
PersProjTrans.InitPersProjTransform(m_persProjInfo);
m_WPtransformation = PersProjTrans * m_Wtransformation;
return m_WPtransformation;
} | [
"[email protected]"
] | |
f6648341acbe8f5dd6ebc0744b4e15cad98cdff2 | 7abbbef9590f9c4b9469adcbae5ea8907478bf03 | /chromium_git/chromium/src/ios/chrome/browser/signin/ios_chrome_signin_status_metrics_provider_delegate.cc | aa1e73745c9cefa67bd8f1675bebfbd572ef8696 | [
"BSD-3-Clause"
] | permissive | GiorgiGagnidze/CEF | 845bdc2f54833254b3454ba8f6c61449431c7884 | fbfc30b5d60f1ea7157da449e34dd9ba9c50f360 | refs/heads/master | 2021-01-10T17:32:27.640882 | 2016-03-23T07:43:04 | 2016-03-23T07:43:04 | 54,463,340 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,847 | cc | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ios/chrome/browser/signin/ios_chrome_signin_status_metrics_provider_delegate.h"
#include "components/signin/core/browser/signin_manager.h"
#include "components/signin/core/browser/signin_status_metrics_provider.h"
#include "ios/chrome/browser/application_context.h"
#include "ios/chrome/browser/browser_state/chrome_browser_state.h"
#include "ios/chrome/browser/signin/signin_manager_factory.h"
#include "ios/public/provider/chrome/browser/browser_state/chrome_browser_state_manager.h"
IOSChromeSigninStatusMetricsProviderDelegate::
IOSChromeSigninStatusMetricsProviderDelegate() {}
IOSChromeSigninStatusMetricsProviderDelegate::
~IOSChromeSigninStatusMetricsProviderDelegate() {
ios::SigninManagerFactory* factory = ios::SigninManagerFactory::GetInstance();
if (factory)
factory->RemoveObserver(this);
}
void IOSChromeSigninStatusMetricsProviderDelegate::Initialize() {
ios::SigninManagerFactory* factory = ios::SigninManagerFactory::GetInstance();
if (factory)
factory->AddObserver(this);
}
AccountsStatus
IOSChromeSigninStatusMetricsProviderDelegate::GetStatusOfAllAccounts() {
std::vector<ios::ChromeBrowserState*> browser_state_list =
GetLoadedChromeBrowserStates();
AccountsStatus accounts_status;
accounts_status.num_accounts = browser_state_list.size();
accounts_status.num_opened_accounts = accounts_status.num_accounts;
for (ios::ChromeBrowserState* browser_state : browser_state_list) {
SigninManager* manager = ios::SigninManagerFactory::GetForBrowserState(
browser_state->GetOriginalChromeBrowserState());
if (manager && manager->IsAuthenticated())
accounts_status.num_signed_in_accounts++;
}
return accounts_status;
}
std::vector<SigninManager*> IOSChromeSigninStatusMetricsProviderDelegate::
GetSigninManagersForAllAccounts() {
std::vector<SigninManager*> managers;
for (ios::ChromeBrowserState* browser_state :
GetLoadedChromeBrowserStates()) {
SigninManager* manager =
ios::SigninManagerFactory::GetForBrowserStateIfExists(browser_state);
if (manager) {
managers.push_back(manager);
}
}
return managers;
}
void IOSChromeSigninStatusMetricsProviderDelegate::SigninManagerCreated(
SigninManager* manager) {
owner()->OnSigninManagerCreated(manager);
}
void IOSChromeSigninStatusMetricsProviderDelegate::SigninManagerShutdown(
SigninManager* manager) {
owner()->OnSigninManagerShutdown(manager);
}
std::vector<ios::ChromeBrowserState*>
IOSChromeSigninStatusMetricsProviderDelegate::GetLoadedChromeBrowserStates() {
return GetApplicationContext()
->GetChromeBrowserStateManager()
->GetLoadedBrowserStates();
}
| [
"[email protected]"
] | |
147528f0a90cac8a572e6af205d1eb4aefdc0a8d | 32f9807703baf6581493553a3269ff702622edfb | /ios/aiai/aiai/srcCode/Tool/Network/userPage/userPage.pb.h | a4f45d00286b40f50567cb36dec639aa8fe010ed | [] | no_license | dafengchuixiaoshu/aiai | 8684deaa71fdd1b21d9784231edea2e66ba9a03b | d366f1489d4e805653e247603873b090639f1dfe | refs/heads/master | 2021-05-10T08:30:17.332605 | 2018-01-25T09:20:47 | 2018-01-25T09:20:47 | 118,889,963 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 32,916 | h | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: userPage.proto
#ifndef PROTOBUF_userPage_2eproto__INCLUDED
#define PROTOBUF_userPage_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
namespace tutorial {
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_userPage_2eproto();
void protobuf_AssignDesc_userPage_2eproto();
void protobuf_ShutdownFile_userPage_2eproto();
class UserPage;
class UserPage_Work;
// ===================================================================
class UserPage_Work : public ::google::protobuf::Message {
public:
UserPage_Work();
virtual ~UserPage_Work();
UserPage_Work(const UserPage_Work& from);
inline UserPage_Work& operator=(const UserPage_Work& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const UserPage_Work& default_instance();
void Swap(UserPage_Work* other);
// implements Message ----------------------------------------------
UserPage_Work* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const UserPage_Work& from);
void MergeFrom(const UserPage_Work& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required string firstKey = 1;
inline bool has_firstkey() const;
inline void clear_firstkey();
static const int kFirstKeyFieldNumber = 1;
inline const ::std::string& firstkey() const;
inline void set_firstkey(const ::std::string& value);
inline void set_firstkey(const char* value);
inline void set_firstkey(const char* value, size_t size);
inline ::std::string* mutable_firstkey();
inline ::std::string* release_firstkey();
inline void set_allocated_firstkey(::std::string* firstkey);
// optional string label = 2;
inline bool has_label() const;
inline void clear_label();
static const int kLabelFieldNumber = 2;
inline const ::std::string& label() const;
inline void set_label(const ::std::string& value);
inline void set_label(const char* value);
inline void set_label(const char* value, size_t size);
inline ::std::string* mutable_label();
inline ::std::string* release_label();
inline void set_allocated_label(::std::string* label);
// optional string face = 3;
inline bool has_face() const;
inline void clear_face();
static const int kFaceFieldNumber = 3;
inline const ::std::string& face() const;
inline void set_face(const ::std::string& value);
inline void set_face(const char* value);
inline void set_face(const char* value, size_t size);
inline ::std::string* mutable_face();
inline ::std::string* release_face();
inline void set_allocated_face(::std::string* face);
// required int64 sendTime = 4;
inline bool has_sendtime() const;
inline void clear_sendtime();
static const int kSendTimeFieldNumber = 4;
inline ::google::protobuf::int64 sendtime() const;
inline void set_sendtime(::google::protobuf::int64 value);
// required int32 praiseCount = 5;
inline bool has_praisecount() const;
inline void clear_praisecount();
static const int kPraiseCountFieldNumber = 5;
inline ::google::protobuf::int32 praisecount() const;
inline void set_praisecount(::google::protobuf::int32 value);
// required int32 sid = 6;
inline bool has_sid() const;
inline void clear_sid();
static const int kSidFieldNumber = 6;
inline ::google::protobuf::int32 sid() const;
inline void set_sid(::google::protobuf::int32 value);
// required string seq = 7;
inline bool has_seq() const;
inline void clear_seq();
static const int kSeqFieldNumber = 7;
inline const ::std::string& seq() const;
inline void set_seq(const ::std::string& value);
inline void set_seq(const char* value);
inline void set_seq(const char* value, size_t size);
inline ::std::string* mutable_seq();
inline ::std::string* release_seq();
inline void set_allocated_seq(::std::string* seq);
// @@protoc_insertion_point(class_scope:tutorial.UserPage.Work)
private:
inline void set_has_firstkey();
inline void clear_has_firstkey();
inline void set_has_label();
inline void clear_has_label();
inline void set_has_face();
inline void clear_has_face();
inline void set_has_sendtime();
inline void clear_has_sendtime();
inline void set_has_praisecount();
inline void clear_has_praisecount();
inline void set_has_sid();
inline void clear_has_sid();
inline void set_has_seq();
inline void clear_has_seq();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::std::string* firstkey_;
::std::string* label_;
::std::string* face_;
::google::protobuf::int64 sendtime_;
::google::protobuf::int32 praisecount_;
::google::protobuf::int32 sid_;
::std::string* seq_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
friend void protobuf_AddDesc_userPage_2eproto();
friend void protobuf_AssignDesc_userPage_2eproto();
friend void protobuf_ShutdownFile_userPage_2eproto();
void InitAsDefaultInstance();
static UserPage_Work* default_instance_;
};
// -------------------------------------------------------------------
class UserPage : public ::google::protobuf::Message {
public:
UserPage();
virtual ~UserPage();
UserPage(const UserPage& from);
inline UserPage& operator=(const UserPage& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const UserPage& default_instance();
void Swap(UserPage* other);
// implements Message ----------------------------------------------
UserPage* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const UserPage& from);
void MergeFrom(const UserPage& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
typedef UserPage_Work Work;
// accessors -------------------------------------------------------
// optional string face = 1;
inline bool has_face() const;
inline void clear_face();
static const int kFaceFieldNumber = 1;
inline const ::std::string& face() const;
inline void set_face(const ::std::string& value);
inline void set_face(const char* value);
inline void set_face(const char* value, size_t size);
inline ::std::string* mutable_face();
inline ::std::string* release_face();
inline void set_allocated_face(::std::string* face);
// optional string nickName = 2;
inline bool has_nickname() const;
inline void clear_nickname();
static const int kNickNameFieldNumber = 2;
inline const ::std::string& nickname() const;
inline void set_nickname(const ::std::string& value);
inline void set_nickname(const char* value);
inline void set_nickname(const char* value, size_t size);
inline ::std::string* mutable_nickname();
inline ::std::string* release_nickname();
inline void set_allocated_nickname(::std::string* nickname);
// optional string sign = 3;
inline bool has_sign() const;
inline void clear_sign();
static const int kSignFieldNumber = 3;
inline const ::std::string& sign() const;
inline void set_sign(const ::std::string& value);
inline void set_sign(const char* value);
inline void set_sign(const char* value, size_t size);
inline ::std::string* mutable_sign();
inline ::std::string* release_sign();
inline void set_allocated_sign(::std::string* sign);
// optional int32 isAttention = 4;
inline bool has_isattention() const;
inline void clear_isattention();
static const int kIsAttentionFieldNumber = 4;
inline ::google::protobuf::int32 isattention() const;
inline void set_isattention(::google::protobuf::int32 value);
// optional string faceVideo = 5;
inline bool has_facevideo() const;
inline void clear_facevideo();
static const int kFaceVideoFieldNumber = 5;
inline const ::std::string& facevideo() const;
inline void set_facevideo(const ::std::string& value);
inline void set_facevideo(const char* value);
inline void set_facevideo(const char* value, size_t size);
inline ::std::string* mutable_facevideo();
inline ::std::string* release_facevideo();
inline void set_allocated_facevideo(::std::string* facevideo);
// optional int32 uid = 6;
inline bool has_uid() const;
inline void clear_uid();
static const int kUidFieldNumber = 6;
inline ::google::protobuf::int32 uid() const;
inline void set_uid(::google::protobuf::int32 value);
// repeated .tutorial.UserPage.Work work = 7;
inline int work_size() const;
inline void clear_work();
static const int kWorkFieldNumber = 7;
inline const ::tutorial::UserPage_Work& work(int index) const;
inline ::tutorial::UserPage_Work* mutable_work(int index);
inline ::tutorial::UserPage_Work* add_work();
inline const ::google::protobuf::RepeatedPtrField< ::tutorial::UserPage_Work >&
work() const;
inline ::google::protobuf::RepeatedPtrField< ::tutorial::UserPage_Work >*
mutable_work();
// @@protoc_insertion_point(class_scope:tutorial.UserPage)
private:
inline void set_has_face();
inline void clear_has_face();
inline void set_has_nickname();
inline void clear_has_nickname();
inline void set_has_sign();
inline void clear_has_sign();
inline void set_has_isattention();
inline void clear_has_isattention();
inline void set_has_facevideo();
inline void clear_has_facevideo();
inline void set_has_uid();
inline void clear_has_uid();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::std::string* face_;
::std::string* nickname_;
::std::string* sign_;
::std::string* facevideo_;
::google::protobuf::int32 isattention_;
::google::protobuf::int32 uid_;
::google::protobuf::RepeatedPtrField< ::tutorial::UserPage_Work > work_;
mutable int _cached_size_;
::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
friend void protobuf_AddDesc_userPage_2eproto();
friend void protobuf_AssignDesc_userPage_2eproto();
friend void protobuf_ShutdownFile_userPage_2eproto();
void InitAsDefaultInstance();
static UserPage* default_instance_;
};
// ===================================================================
// ===================================================================
// UserPage_Work
// required string firstKey = 1;
inline bool UserPage_Work::has_firstkey() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserPage_Work::set_has_firstkey() {
_has_bits_[0] |= 0x00000001u;
}
inline void UserPage_Work::clear_has_firstkey() {
_has_bits_[0] &= ~0x00000001u;
}
inline void UserPage_Work::clear_firstkey() {
if (firstkey_ != &::google::protobuf::internal::kEmptyString) {
firstkey_->clear();
}
clear_has_firstkey();
}
inline const ::std::string& UserPage_Work::firstkey() const {
return *firstkey_;
}
inline void UserPage_Work::set_firstkey(const ::std::string& value) {
set_has_firstkey();
if (firstkey_ == &::google::protobuf::internal::kEmptyString) {
firstkey_ = new ::std::string;
}
firstkey_->assign(value);
}
inline void UserPage_Work::set_firstkey(const char* value) {
set_has_firstkey();
if (firstkey_ == &::google::protobuf::internal::kEmptyString) {
firstkey_ = new ::std::string;
}
firstkey_->assign(value);
}
inline void UserPage_Work::set_firstkey(const char* value, size_t size) {
set_has_firstkey();
if (firstkey_ == &::google::protobuf::internal::kEmptyString) {
firstkey_ = new ::std::string;
}
firstkey_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage_Work::mutable_firstkey() {
set_has_firstkey();
if (firstkey_ == &::google::protobuf::internal::kEmptyString) {
firstkey_ = new ::std::string;
}
return firstkey_;
}
inline ::std::string* UserPage_Work::release_firstkey() {
clear_has_firstkey();
if (firstkey_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = firstkey_;
firstkey_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage_Work::set_allocated_firstkey(::std::string* firstkey) {
if (firstkey_ != &::google::protobuf::internal::kEmptyString) {
delete firstkey_;
}
if (firstkey) {
set_has_firstkey();
firstkey_ = firstkey;
} else {
clear_has_firstkey();
firstkey_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional string label = 2;
inline bool UserPage_Work::has_label() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserPage_Work::set_has_label() {
_has_bits_[0] |= 0x00000002u;
}
inline void UserPage_Work::clear_has_label() {
_has_bits_[0] &= ~0x00000002u;
}
inline void UserPage_Work::clear_label() {
if (label_ != &::google::protobuf::internal::kEmptyString) {
label_->clear();
}
clear_has_label();
}
inline const ::std::string& UserPage_Work::label() const {
return *label_;
}
inline void UserPage_Work::set_label(const ::std::string& value) {
set_has_label();
if (label_ == &::google::protobuf::internal::kEmptyString) {
label_ = new ::std::string;
}
label_->assign(value);
}
inline void UserPage_Work::set_label(const char* value) {
set_has_label();
if (label_ == &::google::protobuf::internal::kEmptyString) {
label_ = new ::std::string;
}
label_->assign(value);
}
inline void UserPage_Work::set_label(const char* value, size_t size) {
set_has_label();
if (label_ == &::google::protobuf::internal::kEmptyString) {
label_ = new ::std::string;
}
label_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage_Work::mutable_label() {
set_has_label();
if (label_ == &::google::protobuf::internal::kEmptyString) {
label_ = new ::std::string;
}
return label_;
}
inline ::std::string* UserPage_Work::release_label() {
clear_has_label();
if (label_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = label_;
label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage_Work::set_allocated_label(::std::string* label) {
if (label_ != &::google::protobuf::internal::kEmptyString) {
delete label_;
}
if (label) {
set_has_label();
label_ = label;
} else {
clear_has_label();
label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional string face = 3;
inline bool UserPage_Work::has_face() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserPage_Work::set_has_face() {
_has_bits_[0] |= 0x00000004u;
}
inline void UserPage_Work::clear_has_face() {
_has_bits_[0] &= ~0x00000004u;
}
inline void UserPage_Work::clear_face() {
if (face_ != &::google::protobuf::internal::kEmptyString) {
face_->clear();
}
clear_has_face();
}
inline const ::std::string& UserPage_Work::face() const {
return *face_;
}
inline void UserPage_Work::set_face(const ::std::string& value) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(value);
}
inline void UserPage_Work::set_face(const char* value) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(value);
}
inline void UserPage_Work::set_face(const char* value, size_t size) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage_Work::mutable_face() {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
return face_;
}
inline ::std::string* UserPage_Work::release_face() {
clear_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = face_;
face_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage_Work::set_allocated_face(::std::string* face) {
if (face_ != &::google::protobuf::internal::kEmptyString) {
delete face_;
}
if (face) {
set_has_face();
face_ = face;
} else {
clear_has_face();
face_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// required int64 sendTime = 4;
inline bool UserPage_Work::has_sendtime() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserPage_Work::set_has_sendtime() {
_has_bits_[0] |= 0x00000008u;
}
inline void UserPage_Work::clear_has_sendtime() {
_has_bits_[0] &= ~0x00000008u;
}
inline void UserPage_Work::clear_sendtime() {
sendtime_ = GOOGLE_LONGLONG(0);
clear_has_sendtime();
}
inline ::google::protobuf::int64 UserPage_Work::sendtime() const {
return sendtime_;
}
inline void UserPage_Work::set_sendtime(::google::protobuf::int64 value) {
set_has_sendtime();
sendtime_ = value;
}
// required int32 praiseCount = 5;
inline bool UserPage_Work::has_praisecount() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserPage_Work::set_has_praisecount() {
_has_bits_[0] |= 0x00000010u;
}
inline void UserPage_Work::clear_has_praisecount() {
_has_bits_[0] &= ~0x00000010u;
}
inline void UserPage_Work::clear_praisecount() {
praisecount_ = 0;
clear_has_praisecount();
}
inline ::google::protobuf::int32 UserPage_Work::praisecount() const {
return praisecount_;
}
inline void UserPage_Work::set_praisecount(::google::protobuf::int32 value) {
set_has_praisecount();
praisecount_ = value;
}
// required int32 sid = 6;
inline bool UserPage_Work::has_sid() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UserPage_Work::set_has_sid() {
_has_bits_[0] |= 0x00000020u;
}
inline void UserPage_Work::clear_has_sid() {
_has_bits_[0] &= ~0x00000020u;
}
inline void UserPage_Work::clear_sid() {
sid_ = 0;
clear_has_sid();
}
inline ::google::protobuf::int32 UserPage_Work::sid() const {
return sid_;
}
inline void UserPage_Work::set_sid(::google::protobuf::int32 value) {
set_has_sid();
sid_ = value;
}
// required string seq = 7;
inline bool UserPage_Work::has_seq() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UserPage_Work::set_has_seq() {
_has_bits_[0] |= 0x00000040u;
}
inline void UserPage_Work::clear_has_seq() {
_has_bits_[0] &= ~0x00000040u;
}
inline void UserPage_Work::clear_seq() {
if (seq_ != &::google::protobuf::internal::kEmptyString) {
seq_->clear();
}
clear_has_seq();
}
inline const ::std::string& UserPage_Work::seq() const {
return *seq_;
}
inline void UserPage_Work::set_seq(const ::std::string& value) {
set_has_seq();
if (seq_ == &::google::protobuf::internal::kEmptyString) {
seq_ = new ::std::string;
}
seq_->assign(value);
}
inline void UserPage_Work::set_seq(const char* value) {
set_has_seq();
if (seq_ == &::google::protobuf::internal::kEmptyString) {
seq_ = new ::std::string;
}
seq_->assign(value);
}
inline void UserPage_Work::set_seq(const char* value, size_t size) {
set_has_seq();
if (seq_ == &::google::protobuf::internal::kEmptyString) {
seq_ = new ::std::string;
}
seq_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage_Work::mutable_seq() {
set_has_seq();
if (seq_ == &::google::protobuf::internal::kEmptyString) {
seq_ = new ::std::string;
}
return seq_;
}
inline ::std::string* UserPage_Work::release_seq() {
clear_has_seq();
if (seq_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = seq_;
seq_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage_Work::set_allocated_seq(::std::string* seq) {
if (seq_ != &::google::protobuf::internal::kEmptyString) {
delete seq_;
}
if (seq) {
set_has_seq();
seq_ = seq;
} else {
clear_has_seq();
seq_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// -------------------------------------------------------------------
// UserPage
// optional string face = 1;
inline bool UserPage::has_face() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserPage::set_has_face() {
_has_bits_[0] |= 0x00000001u;
}
inline void UserPage::clear_has_face() {
_has_bits_[0] &= ~0x00000001u;
}
inline void UserPage::clear_face() {
if (face_ != &::google::protobuf::internal::kEmptyString) {
face_->clear();
}
clear_has_face();
}
inline const ::std::string& UserPage::face() const {
return *face_;
}
inline void UserPage::set_face(const ::std::string& value) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(value);
}
inline void UserPage::set_face(const char* value) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(value);
}
inline void UserPage::set_face(const char* value, size_t size) {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
face_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage::mutable_face() {
set_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
face_ = new ::std::string;
}
return face_;
}
inline ::std::string* UserPage::release_face() {
clear_has_face();
if (face_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = face_;
face_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage::set_allocated_face(::std::string* face) {
if (face_ != &::google::protobuf::internal::kEmptyString) {
delete face_;
}
if (face) {
set_has_face();
face_ = face;
} else {
clear_has_face();
face_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional string nickName = 2;
inline bool UserPage::has_nickname() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserPage::set_has_nickname() {
_has_bits_[0] |= 0x00000002u;
}
inline void UserPage::clear_has_nickname() {
_has_bits_[0] &= ~0x00000002u;
}
inline void UserPage::clear_nickname() {
if (nickname_ != &::google::protobuf::internal::kEmptyString) {
nickname_->clear();
}
clear_has_nickname();
}
inline const ::std::string& UserPage::nickname() const {
return *nickname_;
}
inline void UserPage::set_nickname(const ::std::string& value) {
set_has_nickname();
if (nickname_ == &::google::protobuf::internal::kEmptyString) {
nickname_ = new ::std::string;
}
nickname_->assign(value);
}
inline void UserPage::set_nickname(const char* value) {
set_has_nickname();
if (nickname_ == &::google::protobuf::internal::kEmptyString) {
nickname_ = new ::std::string;
}
nickname_->assign(value);
}
inline void UserPage::set_nickname(const char* value, size_t size) {
set_has_nickname();
if (nickname_ == &::google::protobuf::internal::kEmptyString) {
nickname_ = new ::std::string;
}
nickname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage::mutable_nickname() {
set_has_nickname();
if (nickname_ == &::google::protobuf::internal::kEmptyString) {
nickname_ = new ::std::string;
}
return nickname_;
}
inline ::std::string* UserPage::release_nickname() {
clear_has_nickname();
if (nickname_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = nickname_;
nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage::set_allocated_nickname(::std::string* nickname) {
if (nickname_ != &::google::protobuf::internal::kEmptyString) {
delete nickname_;
}
if (nickname) {
set_has_nickname();
nickname_ = nickname;
} else {
clear_has_nickname();
nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional string sign = 3;
inline bool UserPage::has_sign() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserPage::set_has_sign() {
_has_bits_[0] |= 0x00000004u;
}
inline void UserPage::clear_has_sign() {
_has_bits_[0] &= ~0x00000004u;
}
inline void UserPage::clear_sign() {
if (sign_ != &::google::protobuf::internal::kEmptyString) {
sign_->clear();
}
clear_has_sign();
}
inline const ::std::string& UserPage::sign() const {
return *sign_;
}
inline void UserPage::set_sign(const ::std::string& value) {
set_has_sign();
if (sign_ == &::google::protobuf::internal::kEmptyString) {
sign_ = new ::std::string;
}
sign_->assign(value);
}
inline void UserPage::set_sign(const char* value) {
set_has_sign();
if (sign_ == &::google::protobuf::internal::kEmptyString) {
sign_ = new ::std::string;
}
sign_->assign(value);
}
inline void UserPage::set_sign(const char* value, size_t size) {
set_has_sign();
if (sign_ == &::google::protobuf::internal::kEmptyString) {
sign_ = new ::std::string;
}
sign_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage::mutable_sign() {
set_has_sign();
if (sign_ == &::google::protobuf::internal::kEmptyString) {
sign_ = new ::std::string;
}
return sign_;
}
inline ::std::string* UserPage::release_sign() {
clear_has_sign();
if (sign_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = sign_;
sign_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage::set_allocated_sign(::std::string* sign) {
if (sign_ != &::google::protobuf::internal::kEmptyString) {
delete sign_;
}
if (sign) {
set_has_sign();
sign_ = sign;
} else {
clear_has_sign();
sign_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional int32 isAttention = 4;
inline bool UserPage::has_isattention() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserPage::set_has_isattention() {
_has_bits_[0] |= 0x00000008u;
}
inline void UserPage::clear_has_isattention() {
_has_bits_[0] &= ~0x00000008u;
}
inline void UserPage::clear_isattention() {
isattention_ = 0;
clear_has_isattention();
}
inline ::google::protobuf::int32 UserPage::isattention() const {
return isattention_;
}
inline void UserPage::set_isattention(::google::protobuf::int32 value) {
set_has_isattention();
isattention_ = value;
}
// optional string faceVideo = 5;
inline bool UserPage::has_facevideo() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserPage::set_has_facevideo() {
_has_bits_[0] |= 0x00000010u;
}
inline void UserPage::clear_has_facevideo() {
_has_bits_[0] &= ~0x00000010u;
}
inline void UserPage::clear_facevideo() {
if (facevideo_ != &::google::protobuf::internal::kEmptyString) {
facevideo_->clear();
}
clear_has_facevideo();
}
inline const ::std::string& UserPage::facevideo() const {
return *facevideo_;
}
inline void UserPage::set_facevideo(const ::std::string& value) {
set_has_facevideo();
if (facevideo_ == &::google::protobuf::internal::kEmptyString) {
facevideo_ = new ::std::string;
}
facevideo_->assign(value);
}
inline void UserPage::set_facevideo(const char* value) {
set_has_facevideo();
if (facevideo_ == &::google::protobuf::internal::kEmptyString) {
facevideo_ = new ::std::string;
}
facevideo_->assign(value);
}
inline void UserPage::set_facevideo(const char* value, size_t size) {
set_has_facevideo();
if (facevideo_ == &::google::protobuf::internal::kEmptyString) {
facevideo_ = new ::std::string;
}
facevideo_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserPage::mutable_facevideo() {
set_has_facevideo();
if (facevideo_ == &::google::protobuf::internal::kEmptyString) {
facevideo_ = new ::std::string;
}
return facevideo_;
}
inline ::std::string* UserPage::release_facevideo() {
clear_has_facevideo();
if (facevideo_ == &::google::protobuf::internal::kEmptyString) {
return NULL;
} else {
::std::string* temp = facevideo_;
facevideo_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
return temp;
}
}
inline void UserPage::set_allocated_facevideo(::std::string* facevideo) {
if (facevideo_ != &::google::protobuf::internal::kEmptyString) {
delete facevideo_;
}
if (facevideo) {
set_has_facevideo();
facevideo_ = facevideo;
} else {
clear_has_facevideo();
facevideo_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
}
}
// optional int32 uid = 6;
inline bool UserPage::has_uid() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UserPage::set_has_uid() {
_has_bits_[0] |= 0x00000020u;
}
inline void UserPage::clear_has_uid() {
_has_bits_[0] &= ~0x00000020u;
}
inline void UserPage::clear_uid() {
uid_ = 0;
clear_has_uid();
}
inline ::google::protobuf::int32 UserPage::uid() const {
return uid_;
}
inline void UserPage::set_uid(::google::protobuf::int32 value) {
set_has_uid();
uid_ = value;
}
// repeated .tutorial.UserPage.Work work = 7;
inline int UserPage::work_size() const {
return work_.size();
}
inline void UserPage::clear_work() {
work_.Clear();
}
inline const ::tutorial::UserPage_Work& UserPage::work(int index) const {
return work_.Get(index);
}
inline ::tutorial::UserPage_Work* UserPage::mutable_work(int index) {
return work_.Mutable(index);
}
inline ::tutorial::UserPage_Work* UserPage::add_work() {
return work_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::tutorial::UserPage_Work >&
UserPage::work() const {
return work_;
}
inline ::google::protobuf::RepeatedPtrField< ::tutorial::UserPage_Work >*
UserPage::mutable_work() {
return &work_;
}
// @@protoc_insertion_point(namespace_scope)
} // namespace tutorial
#ifndef SWIG
namespace google {
namespace protobuf {
} // namespace google
} // namespace protobuf
#endif // SWIG
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_userPage_2eproto__INCLUDED
| [
"[email protected]"
] | |
9ba1984fc53d1131fc6d665375dd31d08cae04f6 | b4f19ec1b2956d336cf56a409546d9c7502106c3 | /Thanadolos World/CharacterSelectedErrorMessage.cpp | 31d46c047a1272a732cfebfabc21b3aca1680af9 | [] | no_license | w0dm4n/Thanadolos | d3095a8aec322270cf94d70f4709396ef6275cd2 | 35086d7658175735c6490a188d42580afdbd6c14 | refs/heads/master | 2021-03-16T05:54:11.638301 | 2017-06-19T22:54:17 | 2017-06-19T22:54:17 | 90,393,751 | 18 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 479 | cpp | #include "Globals.h"
#include "CharacterSelectedErrorMessage.hpp"
CharacterSelectedErrorMessage::CharacterSelectedErrorMessage()
{
}
ushort CharacterSelectedErrorMessage::getId()
{
return id;
}
std::string CharacterSelectedErrorMessage::getName()
{
return "CharacterSelectedErrorMessage";
}
void CharacterSelectedErrorMessage::serialize(BinaryWriter& writer)
{
}
void CharacterSelectedErrorMessage::deserialize(BinaryReader& reader)
{
{
}
} | [
"[email protected]"
] | |
47fd63e5479270c9bd9ae7fa887f235848af6d3e | 5bc47dcf9ab0843b9d06bc25012bcb2f78874216 | /1332D.cpp | bd23d7ee66e5ffcb415025df9f6d25315842f72c | [] | no_license | MijaTola/Codeforce | 428f466248a4e9d42ac457aa971f681320dc5018 | 9e85803464ed192c6c643bd0f920f345503ac967 | refs/heads/master | 2021-01-10T16:27:12.479907 | 2020-10-14T15:00:14 | 2020-10-14T15:00:14 | 45,284,776 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 279 | cpp | #include <bits/stdc++.h>
using namespace std;
int ans[4][4];
int n,m;
int main() {
int k;
cin >> k;
cout << "4 4\n";
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
ans[i][j] = (1 << 19);
return 0;
}
| [
"[email protected]"
] | |
d90f28041110979ac4e00cd3442367acd3f9b99f | 9b5edf3ad0be8476150beb6f815c82480a3881d4 | /INTTERUPT_ATTINY85/INTTERUPT_ATTINY85.ino | ddebc5a82139ee8444ee2a06ad4214d220232893 | [] | no_license | divyanshbhowmick/Getting-Hands-on-ATTINY-85 | e1cf297cf81badabce3f04d61be0bae5a69858b8 | 4ee11f6682b59ebd7ea4cba9532dc293b9d2ce68 | refs/heads/master | 2020-06-30T14:12:10.591677 | 2019-08-22T05:49:57 | 2019-08-22T05:49:57 | 200,852,316 | 0 | 0 | null | 2019-08-22T05:49:58 | 2019-08-06T13:00:31 | C++ | UTF-8 | C++ | false | false | 1,974 | ino | /**
Author: Divyansh Bhowmick
Description: Programming ATTINY85 using Arduino as ISP.
Language Used: Embedded C
Steps for programming the micro-controller ATTINY85.
1) Upload the Arduino ISP program onto Arduino UNO board
2) Connect Arduino with ATTINY 85
ATTINY85 PINS ARDUINO PINS
1 ----------- 10
5 ----------- 11
6 ----------- 12
7 ----------- 13
8 ----------- 5V
4 ----------- GND
3) Write the code for the ATTINY 85 and select the board ATTINY85 and Programmer to Arduino as ISP.
4) Just upload the code and enjoy!
Steps for viewing the output on Serial monitor.
1) Use the SoftwareSerial Library and define the RX and TX pins.
2) Select the board to Arduino UNO and dump a blank code onto it.
3) Connect the RX and TX pins to 0 and 1 pin of Arduino.
4) Open the Serial monitor and observe the ouput.
Ready, to rock!
**/
#include<avr/io.h>
#include<util/delay.h>
#include<avr/interrupt.h>
#define LED1 PB0 //Defining the LED pin
#define BTN PB1 //Defining the Button pin
#define LED_ON PORTB |= (1 << LED1); //Defining a macro for turning on the LED
#define LED_OFF PORTB &= ~(1<<LED1); //Defining a macro for turining off the LED
#define SWITCH_PRESSED !(PINB & (1 << PINB1))
//Defining the interrupt service routine
ISR(PCINT0_vect) {
if (SWITCH_PRESSED) //Reading the status of PINB1
{
LED_OFF;
}
else {
LED_ON;
}
}
void setup() {
DDRB |= (1 << LED1); //Setting LED1 as output
DDRB &= ~(1 << BTN); //Setting BTN as input
PORTB |= (1 << BTN); //Setiing BTN as input pullup
PCMSK |= (1 << PCINT3); //Enabling the Pin Change Mask Register
GIMSK |= (1 << PCIE); // Setting the Pin Change Interrupt Enable bit of General Interrupt Mask Register.
sei(); //Setting the I bit of AVR Status Register
}
void loop() {
}
| [
"[email protected]"
] | |
2eff890c230be247e25e3da82d95eca52e931a14 | 0178312980eb4aa31e23d337ad3fbf244ba21ce9 | /sstt/libs/DX9Hook/imgui.cpp | 21a152dd5711e1074096d7ec1378978945f99e46 | [] | no_license | TheMrThor/sstt | b031aa626336a33d236a8135d706278de396df3d | 9cebfb7dc8bd69fdcc52c3b32d92ea8755b2bb82 | refs/heads/master | 2023-07-08T13:18:31.607103 | 2021-08-09T08:29:37 | 2021-08-09T08:29:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 404,746 | cpp | // dear imgui, v1.49 WIP
// (main code and documentation)
// See ImGui::ShowTestWindow() in imgui_demo.cpp for demo code.
// Newcomers, read 'Programmer guide' below for notes on how to setup ImGui in your codebase.
// Get latest version at https://github.com/ocornut/imgui
// Releases change-log at https://github.com/ocornut/imgui/releases
// Developed by Omar Cornut and every direct or indirect contributors to the GitHub.
// This library is free but I need your support to sustain development and maintenance.
// If you work for a company, please consider financial support, e.g: https://www.patreon.com/imgui
/*
Index
- MISSION STATEMENT
- END-USER GUIDE
- PROGRAMMER GUIDE (read me!)
- API BREAKING CHANGES (read me when you update!)
- FREQUENTLY ASKED QUESTIONS (FAQ), TIPS
- How can I help?
- How do I update to a newer version of ImGui?
- What is ImTextureID and how do I display an image?
- Can I have multiple widgets with the same label? Can I have widget without a label? (Yes) / A primer on the use of labels/IDs in ImGui.
- I integrated ImGui in my engine and the text or lines are blurry..
- I integrated ImGui in my engine and some elements are clipping or disappearing when I move windows around..
- How can I load a different font than the default?
- How can I load multiple fonts?
- How can I display and input non-latin characters such as Chinese, Japanese, Korean, Cyrillic?
- ISSUES & TODO-LIST
- CODE
MISSION STATEMENT
=================
- easy to use to create code-driven and data-driven tools
- easy to use to create ad hoc short-lived tools and long-lived, more elaborate tools
- easy to hack and improve
- minimize screen real-estate usage
- minimize setup and maintenance
- minimize state storage on user side
- portable, minimize dependencies, run on target (consoles, phones, etc.)
- efficient runtime (NB- we do allocate when "growing" content - creating a window / opening a tree node for the first time, etc. - but a typical frame won't allocate anything)
- read about immediate-mode gui principles @ http://mollyrocket.com/861, http://mollyrocket.com/forums/index.html
Designed for developers and content-creators, not the typical end-user! Some of the weaknesses includes:
- doesn't look fancy, doesn't animate
- limited layout features, intricate layouts are typically crafted in code
- occasionally uses statically sized buffers for string manipulations - won't crash, but some very long pieces of text may be clipped. functions like ImGui::TextUnformatted() don't have such restriction.
END-USER GUIDE
==============
- double-click title bar to collapse window
- click upper right corner to close a window, available when 'bool* p_opened' is passed to ImGui::Begin()
- click and drag on lower right corner to resize window
- click and drag on any empty space to move window
- double-click/double-tap on lower right corner grip to auto-fit to content
- TAB/SHIFT+TAB to cycle through keyboard editable fields
- use mouse wheel to scroll
- use CTRL+mouse wheel to zoom window contents (if IO.FontAllowScaling is true)
- CTRL+Click on a slider or drag box to input value as text
- text editor:
- Hold SHIFT or use mouse to select text.
- CTRL+Left/Right to word jump
- CTRL+Shift+Left/Right to select words
- CTRL+A our Double-Click to select all
- CTRL+X,CTRL+C,CTRL+V to use OS clipboard
- CTRL+Z,CTRL+Y to undo/redo
- ESCAPE to revert text to its original value
- You can apply arithmetic operators +,*,/ on numerical values. Use +- to subtract (because - would set a negative value!)
PROGRAMMER GUIDE
================
- read the FAQ below this section!
- your code creates the UI, if your code doesn't run the UI is gone! == very dynamic UI, no construction/destructions steps, less data retention on your side, no state duplication, less sync, less bugs.
- call and read ImGui::ShowTestWindow() for demo code demonstrating most features.
- see examples/ folder for standalone sample applications. Prefer reading examples/opengl_example/ first at it is the simplest.
you may be able to grab and copy a ready made imgui_impl_*** file from the examples/.
- customization: PushStyleColor()/PushStyleVar() or the style editor to tweak the look of the interface (e.g. if you want a more compact UI or a different color scheme).
- getting started:
- init: call ImGui::GetIO() to retrieve the ImGuiIO structure and fill the fields marked 'Settings'.
- init: call io.Fonts->GetTexDataAsRGBA32(...) and load the font texture pixels into graphics memory.
- every frame:
1/ in your mainloop or right after you got your keyboard/mouse info, call ImGui::GetIO() and fill the fields marked 'Input'
2/ call ImGui::NewFrame() as early as you can!
3/ use any ImGui function you want between NewFrame() and Render()
4/ call ImGui::Render() as late as you can to end the frame and finalize render data. it will call your RenderDrawListFn handler that you set in the IO structure.
(if you don't need to render, you still need to call Render() and ignore the callback, or call EndFrame() instead. if you call neither some aspects of windows focusing/moving will appear broken.)
- all rendering information are stored into command-lists until ImGui::Render() is called.
- ImGui never touches or know about your GPU state. the only function that knows about GPU is the RenderDrawListFn handler that you provide.
- effectively it means you can create widgets at any time in your code, regardless of considerations of being in "update" vs "render" phases of your own application.
- refer to the examples applications in the examples/ folder for instruction on how to setup your code.
- a typical application skeleton may be:
// Application init
ImGuiIO& io = ImGui::GetIO();
io.DisplaySize.x = 1920.0f;
io.DisplaySize.y = 1280.0f;
io.IniFilename = "imgui.ini";
io.RenderDrawListsFn = my_render_function; // Setup a render function, or set to NULL and call GetDrawData() after Render() to access the render data.
// TODO: Fill others settings of the io structure
// Load texture atlas
// There is a default font so you don't need to care about choosing a font yet
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(pixels, &width, &height);
// TODO: At this points you've got a texture pointed to by 'pixels' and you need to upload that your your graphic system
// TODO: Store your texture pointer/identifier (whatever your engine uses) in 'io.Fonts->TexID'
// Application main loop
while (true)
{
// 1) get low-level inputs (e.g. on Win32, GetKeyboardState(), or poll your events, etc.)
// TODO: fill all fields of IO structure and call NewFrame
ImGuiIO& io = ImGui::GetIO();
io.DeltaTime = 1.0f/60.0f;
io.MousePos = mouse_pos;
io.MouseDown[0] = mouse_button_0;
io.MouseDown[1] = mouse_button_1;
io.KeysDown[i] = ...
// 2) call NewFrame(), after this point you can use ImGui::* functions anytime
ImGui::NewFrame();
// 3) most of your application code here
ImGui::Begin("My window");
ImGui::Text("Hello, world.");
ImGui::End();
MyGameUpdate(); // may use ImGui functions
MyGameRender(); // may use ImGui functions
// 4) render & swap video buffers
ImGui::Render();
SwapBuffers();
}
- after calling ImGui::NewFrame() you can read back flags from the IO structure to tell how ImGui intends to use your inputs.
When 'io.WantCaptureMouse' or 'io.WantCaptureKeyboard' flags are set you may want to discard/hide the inputs from the rest of your application.
When 'io.WantInputsCharacters' is set to may want to notify your OS to popup an on-screen keyboard, if available.
API BREAKING CHANGES
====================
Occasionally introducing changes that are breaking the API. The breakage are generally minor and easy to fix.
Here is a change-log of API breaking changes, if you are using one of the functions listed, expect to have to fix some code.
Also read releases logs https://github.com/ocornut/imgui/releases for more details.
- 2016/04/03 (1.48) - removed style.WindowFillAlphaDefault setting which was redundant. Bake default BG alpha inside style.Colors[ImGuiCol_WindowBg] and all other Bg color values. (ref github issue #337).
- 2016/04/03 (1.48) - renamed ImGuiCol_TooltipBg to ImGuiCol_PopupBg, used by popups/menus and tooltips. popups/menus were previously using ImGuiCol_WindowBg. (ref github issue #337)
- 2016/03/21 (1.48) - renamed GetWindowFont() to GetFont(), GetWindowFontSize() to GetFontSize(). Kept inline redirection function (will obsolete).
- 2016/03/02 (1.48) - InputText() completion/history/always callbacks: if you modify the text buffer manually (without using DeleteChars()/InsertChars() helper) you need to maintain the BufTextLen field. added an assert.
- 2016/01/23 (1.48) - fixed not honoring exact width passed to PushItemWidth(), previously it would add extra FramePadding.x*2 over that width. if you had manual pixel-perfect alignment in place it might affect you.
- 2015/12/27 (1.48) - fixed ImDrawList::AddRect() which used to render a rectangle 1 px too large on each axis.
- 2015/12/04 (1.47) - renamed Color() helpers to ValueColor() - dangerously named, rarely used and probably to be made obsolete.
- 2015/08/29 (1.45) - with the addition of horizontal scrollbar we made various fixes to inconsistencies with dealing with cursor position.
GetCursorPos()/SetCursorPos() functions now include the scrolled amount. It shouldn't affect the majority of users, but take note that SetCursorPosX(100.0f) puts you at +100 from the starting x position which may include scrolling, not at +100 from the window left side.
GetContentRegionMax()/GetWindowContentRegionMin()/GetWindowContentRegionMax() functions allow include the scrolled amount. Typically those were used in cases where no scrolling would happen so it may not be a problem, but watch out!
- 2015/08/29 (1.45) - renamed style.ScrollbarWidth to style.ScrollbarSize
- 2015/08/05 (1.44) - split imgui.cpp into extra files: imgui_demo.cpp imgui_draw.cpp imgui_internal.h that you need to add to your project.
- 2015/07/18 (1.44) - fixed angles in ImDrawList::PathArcTo(), PathArcToFast() (introduced in 1.43) being off by an extra PI for no justifiable reason
- 2015/07/14 (1.43) - add new ImFontAtlas::AddFont() API. For the old AddFont***, moved the 'font_no' parameter of ImFontAtlas::AddFont** functions to the ImFontConfig structure.
you need to render your textured triangles with bilinear filtering to benefit from sub-pixel positioning of text.
- 2015/07/08 (1.43) - switched rendering data to use indexed rendering. this is saving a fair amount of CPU/GPU and enables us to get anti-aliasing for a marginal cost.
this necessary change will break your rendering function! the fix should be very easy. sorry for that :(
- if you are using a vanilla copy of one of the imgui_impl_XXXX.cpp provided in the example, you just need to update your copy and you can ignore the rest.
- the signature of the io.RenderDrawListsFn handler has changed!
ImGui_XXXX_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_count)
became:
ImGui_XXXX_RenderDrawLists(ImDrawData* draw_data).
argument 'cmd_lists' -> 'draw_data->CmdLists'
argument 'cmd_lists_count' -> 'draw_data->CmdListsCount'
ImDrawList 'commands' -> 'CmdBuffer'
ImDrawList 'vtx_buffer' -> 'VtxBuffer'
ImDrawList n/a -> 'IdxBuffer' (new)
ImDrawCmd 'vtx_count' -> 'ElemCount'
ImDrawCmd 'clip_rect' -> 'ClipRect'
ImDrawCmd 'user_callback' -> 'UserCallback'
ImDrawCmd 'texture_id' -> 'TextureId'
- each ImDrawList now contains both a vertex buffer and an index buffer. For each command, render ElemCount/3 triangles using indices from the index buffer.
- if you REALLY cannot render indexed primitives, you can call the draw_data->DeIndexAllBuffers() method to de-index the buffers. This is slow and a waste of CPU/GPU. Prefer using indexed rendering!
- refer to code in the examples/ folder or ask on the GitHub if you are unsure of how to upgrade. please upgrade!
- 2015/07/10 (1.43) - changed SameLine() parameters from int to float.
- 2015/07/02 (1.42) - renamed SetScrollPosHere() to SetScrollFromCursorPos(). Kept inline redirection function (will obsolete).
- 2015/07/02 (1.42) - renamed GetScrollPosY() to GetScrollY(). Necessary to reduce confusion along with other scrolling functions, because positions (e.g. cursor position) are not equivalent to scrolling amount.
- 2015/06/14 (1.41) - changed ImageButton() default bg_col parameter from (0,0,0,1) (black) to (0,0,0,0) (transparent) - makes a difference when texture have transparence
- 2015/06/14 (1.41) - changed Selectable() API from (label, selected, size) to (label, selected, flags, size). Size override should have been rarely be used. Sorry!
- 2015/05/31 (1.40) - renamed GetWindowCollapsed() to IsWindowCollapsed() for consistency. Kept inline redirection function (will obsolete).
- 2015/05/31 (1.40) - renamed IsRectClipped() to IsRectVisible() for consistency. Note that return value is opposite! Kept inline redirection function (will obsolete).
- 2015/05/27 (1.40) - removed the third 'repeat_if_held' parameter from Button() - sorry! it was rarely used and inconsistent. Use PushButtonRepeat(true) / PopButtonRepeat() to enable repeat on desired buttons.
- 2015/05/11 (1.40) - changed BeginPopup() API, takes a string identifier instead of a bool. ImGui needs to manage the open/closed state of popups. Call OpenPopup() to actually set the "opened" state of a popup. BeginPopup() returns true if the popup is opened.
- 2015/05/03 (1.40) - removed style.AutoFitPadding, using style.WindowPadding makes more sense (the default values were already the same).
- 2015/04/13 (1.38) - renamed IsClipped() to IsRectClipped(). Kept inline redirection function (will obsolete).
- 2015/04/09 (1.38) - renamed ImDrawList::AddArc() to ImDrawList::AddArcFast() for compatibility with future API
- 2015/04/03 (1.38) - removed ImGuiCol_CheckHovered, ImGuiCol_CheckActive, replaced with the more general ImGuiCol_FrameBgHovered, ImGuiCol_FrameBgActive.
- 2014/04/03 (1.38) - removed support for passing -FLT_MAX..+FLT_MAX as the range for a SliderFloat(). Use DragFloat() or Inputfloat() instead.
- 2015/03/17 (1.36) - renamed GetItemBoxMin()/GetItemBoxMax()/IsMouseHoveringBox() to GetItemRectMin()/GetItemRectMax()/IsMouseHoveringRect(). Kept inline redirection function (will obsolete).
- 2015/03/15 (1.36) - renamed style.TreeNodeSpacing to style.IndentSpacing, ImGuiStyleVar_TreeNodeSpacing to ImGuiStyleVar_IndentSpacing
- 2015/03/13 (1.36) - renamed GetWindowIsFocused() to IsWindowFocused(). Kept inline redirection function (will obsolete).
- 2015/03/08 (1.35) - renamed style.ScrollBarWidth to style.ScrollbarWidth (casing)
- 2015/02/27 (1.34) - renamed OpenNextNode(bool) to SetNextTreeNodeOpened(bool, ImGuiSetCond). Kept inline redirection function (will obsolete).
- 2015/02/27 (1.34) - renamed ImGuiSetCondition_*** to ImGuiSetCond_***, and _FirstUseThisSession becomes _Once.
- 2015/02/11 (1.32) - changed text input callback ImGuiTextEditCallback return type from void-->int. reserved for future use, return 0 for now.
- 2015/02/10 (1.32) - renamed GetItemWidth() to CalcItemWidth() to clarify its evolving behavior
- 2015/02/08 (1.31) - renamed GetTextLineSpacing() to GetTextLineHeightWithSpacing()
- 2015/02/01 (1.31) - removed IO.MemReallocFn (unused)
- 2015/01/19 (1.30) - renamed ImGuiStorage::GetIntPtr()/GetFloatPtr() to GetIntRef()/GetIntRef() because Ptr was conflicting with actual pointer storage functions.
- 2015/01/11 (1.30) - big font/image API change! now loads TTF file. allow for multiple fonts. no need for a PNG loader.
(1.30) - removed GetDefaultFontData(). uses io.Fonts->GetTextureData*() API to retrieve uncompressed pixels.
this sequence:
const void* png_data;
unsigned int png_size;
ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
// <Copy to GPU>
became:
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
// <Copy to GPU>
io.Fonts->TexID = (your_texture_identifier);
you now have much more flexibility to load multiple TTF fonts and manage the texture buffer for internal needs.
it is now recommended that you sample the font texture with bilinear interpolation.
(1.30) - added texture identifier in ImDrawCmd passed to your render function (we can now render images). make sure to set io.Fonts->TexID.
(1.30) - removed IO.PixelCenterOffset (unnecessary, can be handled in user projection matrix)
(1.30) - removed ImGui::IsItemFocused() in favor of ImGui::IsItemActive() which handles all widgets
- 2014/12/10 (1.18) - removed SetNewWindowDefaultPos() in favor of new generic API SetNextWindowPos(pos, ImGuiSetCondition_FirstUseEver)
- 2014/11/28 (1.17) - moved IO.Font*** options to inside the IO.Font-> structure (FontYOffset, FontTexUvForWhite, FontBaseScale, FontFallbackGlyph)
- 2014/11/26 (1.17) - reworked syntax of IMGUI_ONCE_UPON_A_FRAME helper macro to increase compiler compatibility
- 2014/11/07 (1.15) - renamed IsHovered() to IsItemHovered()
- 2014/10/02 (1.14) - renamed IMGUI_INCLUDE_IMGUI_USER_CPP to IMGUI_INCLUDE_IMGUI_USER_INL and imgui_user.cpp to imgui_user.inl (more IDE friendly)
- 2014/09/25 (1.13) - removed 'text_end' parameter from IO.SetClipboardTextFn (the string is now always zero-terminated for simplicity)
- 2014/09/24 (1.12) - renamed SetFontScale() to SetWindowFontScale()
- 2014/09/24 (1.12) - moved IM_MALLOC/IM_REALLOC/IM_FREE preprocessor defines to IO.MemAllocFn/IO.MemReallocFn/IO.MemFreeFn
- 2014/08/30 (1.09) - removed IO.FontHeight (now computed automatically)
- 2014/08/30 (1.09) - moved IMGUI_FONT_TEX_UV_FOR_WHITE preprocessor define to IO.FontTexUvForWhite
- 2014/08/28 (1.09) - changed the behavior of IO.PixelCenterOffset following various rendering fixes
FREQUENTLY ASKED QUESTIONS (FAQ), TIPS
======================================
Q: How can I help?
A: - If you are experienced enough with ImGui and with C/C++, look at the todo list and see how you want/can help!
- Become a Patron/donate. Convince your company to become a Patron or provide serious funding for development time.
Q: How do I update to a newer version of ImGui?
A: Overwrite the following files:
imgui.cpp
imgui.h
imgui_demo.cpp
imgui_draw.cpp
imgui_internal.h
stb_rect_pack.h
stb_textedit.h
stb_truetype.h
Don't overwrite imconfig.h if you have made modification to your copy.
Check the "API BREAKING CHANGES" sections for a list of occasional API breaking changes. If you have a problem with a function, search for its name
in the code, there will likely be a comment about it. Please report any issue to the GitHub page!
Q: What is ImTextureID and how do I display an image?
A: ImTextureID is a void* used to pass renderer-agnostic texture references around until it hits your render function.
ImGui knows nothing about what those bits represent, it just passes them around. It is up to you to decide what you want the void* to carry!
It could be an identifier to your OpenGL texture (cast GLuint to void*), a pointer to your custom engine material (cast MyMaterial* to void*), etc.
At the end of the chain, your renderer takes this void* to cast it back into whatever it needs to select a current texture to render.
Refer to examples applications, where each renderer (in a imgui_impl_xxxx.cpp file) is treating ImTextureID as a different thing.
(c++ tip: OpenGL uses integers to identify textures. You can safely store an integer into a void*, just cast it to void*, don't take it's address!)
To display a custom image/texture within an ImGui window, you may use ImGui::Image(), ImGui::ImageButton(), ImDrawList::AddImage() functions.
ImGui will generate the geometry and draw calls using the ImTextureID that you passed and which your renderer can use.
It is your responsibility to get textures uploaded to your GPU.
Q: Can I have multiple widgets with the same label? Can I have widget without a label? (Yes)
A: Yes. A primer on the use of labels/IDs in ImGui..
- Elements that are not clickable, such as Text() items don't need an ID.
- Interactive widgets require state to be carried over multiple frames (most typically ImGui often needs to remember what is the "active" widget).
to do so they need an unique ID. unique ID are typically derived from a string label, an integer index or a pointer.
Button("OK"); // Label = "OK", ID = hash of "OK"
Button("Cancel"); // Label = "Cancel", ID = hash of "Cancel"
- ID are uniquely scoped within windows, tree nodes, etc. so no conflict can happen if you have two buttons called "OK" in two different windows
or in two different locations of a tree.
- If you have a same ID twice in the same location, you'll have a conflict:
Button("OK");
Button("OK"); // ID collision! Both buttons will be treated as the same.
Fear not! this is easy to solve and there are many ways to solve it!
- When passing a label you can optionally specify extra unique ID information within string itself. This helps solving the simpler collision cases.
use "##" to pass a complement to the ID that won't be visible to the end-user:
Button("Play"); // Label = "Play", ID = hash of "Play"
Button("Play##foo1"); // Label = "Play", ID = hash of "Play##foo1" (different from above)
Button("Play##foo2"); // Label = "Play", ID = hash of "Play##foo2" (different from above)
- If you want to completely hide the label, but still need an ID:
Checkbox("##On", &b); // Label = "", ID = hash of "##On" (no label!)
- Occasionally/rarely you might want change a label while preserving a constant ID. This allows you to animate labels.
For example you may want to include varying information in a window title bar (and windows are uniquely identified by their ID.. obviously)
Use "###" to pass a label that isn't part of ID:
Button("Hello###ID"; // Label = "Hello", ID = hash of "ID"
Button("World###ID"; // Label = "World", ID = hash of "ID" (same as above)
sprintf(buf, "My game (%f FPS)###MyGame");
Begin(buf); // Variable label, ID = hash of "MyGame"
- Use PushID() / PopID() to create scopes and avoid ID conflicts within the same Window.
This is the most convenient way of distinguishing ID if you are iterating and creating many UI elements.
You can push a pointer, a string or an integer value. Remember that ID are formed from the concatenation of everything in the ID stack!
for (int i = 0; i < 100; i++)
{
PushID(i);
Button("Click"); // Label = "Click", ID = hash of integer + "label" (unique)
PopID();
}
for (int i = 0; i < 100; i++)
{
MyObject* obj = Objects[i];
PushID(obj);
Button("Click"); // Label = "Click", ID = hash of pointer + "label" (unique)
PopID();
}
for (int i = 0; i < 100; i++)
{
MyObject* obj = Objects[i];
PushID(obj->Name);
Button("Click"); // Label = "Click", ID = hash of string + "label" (unique)
PopID();
}
- More example showing that you can stack multiple prefixes into the ID stack:
Button("Click"); // Label = "Click", ID = hash of "Click"
PushID("node");
Button("Click"); // Label = "Click", ID = hash of "node" + "Click"
PushID(my_ptr);
Button("Click"); // Label = "Click", ID = hash of "node" + ptr + "Click"
PopID();
PopID();
- Tree nodes implicitly creates a scope for you by calling PushID().
Button("Click"); // Label = "Click", ID = hash of "Click"
if (TreeNode("node"))
{
Button("Click"); // Label = "Click", ID = hash of "node" + "Click"
TreePop();
}
- When working with trees, ID are used to preserve the opened/closed state of each tree node.
Depending on your use cases you may want to use strings, indices or pointers as ID.
e.g. when displaying a single object that may change over time (1-1 relationship), using a static string as ID will preserve your node open/closed state when the targeted object change.
e.g. when displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state differently. experiment and see what makes more sense!
Q: I integrated ImGui in my engine and the text or lines are blurry..
A: In your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f).
Also make sure your orthographic projection matrix and io.DisplaySize matches your actual framebuffer dimension.
Q: I integrated ImGui in my engine and some elements are clipping or disappearing when I move windows around..
A: Most likely you are mishandling the clipping rectangles in your render function. Rectangles provided by ImGui are defined as (x1,y1,x2,y2) and NOT as (x1,y1,width,height).
Q: How can I load a different font than the default? (default is an embedded version of ProggyClean.ttf, rendered at size 13)
A: Use the font atlas to load the TTF file you want:
ImGuiIO& io = ImGui::GetIO();
io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels);
io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()
Q: How can I load multiple fonts?
A: Use the font atlas to pack them into a single texture:
(Read extra_fonts/README.txt and the code in ImFontAtlas for more details.)
ImGuiIO& io = ImGui::GetIO();
ImFont* font0 = io.Fonts->AddFontDefault();
ImFont* font1 = io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels);
ImFont* font2 = io.Fonts->AddFontFromFileTTF("myfontfile2.ttf", size_in_pixels);
io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()
// the first loaded font gets used by default
// use ImGui::PushFont()/ImGui::PopFont() to change the font at runtime
// Options
ImFontConfig config;
config.OversampleH = 3;
config.OversampleV = 1;
config.GlyphExtraSpacing.x = 1.0f;
io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, &config);
// Combine multiple fonts into one
ImWchar ranges[] = { 0xf000, 0xf3ff, 0 };
ImFontConfig config;
config.MergeMode = true;
io.Fonts->AddFontDefault();
io.Fonts->LoadFromFileTTF("fontawesome-webfont.ttf", 16.0f, &config, ranges);
io.Fonts->LoadFromFileTTF("myfontfile.ttf", size_pixels, NULL, &config, io.Fonts->GetGlyphRangesJapanese());
Q: How can I display and input non-Latin characters such as Chinese, Japanese, Korean, Cyrillic?
A: When loading a font, pass custom Unicode ranges to specify the glyphs to load. ImGui will support UTF-8 encoding across the board.
Character input depends on you passing the right character code to io.AddInputCharacter(). The example applications do that.
io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels, NULL, io.Fonts->GetGlyphRangesJapanese()); // Load Japanese characters
io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()
io.ImeWindowHandle = MY_HWND; // To input using Microsoft IME, give ImGui the hwnd of your application
- tip: the construct 'IMGUI_ONCE_UPON_A_FRAME { ... }' will run the block of code only once a frame. You can use it to quickly add custom UI in the middle of a deep nested inner loop in your code.
- tip: you can create widgets without a Begin()/End() block, they will go in an implicit window called "Debug"
- tip: you can call Begin() multiple times with the same name during the same frame, it will keep appending to the same window. this is also useful to set yourself in the context of another window (to get/set other settings)
- tip: you can call Render() multiple times (e.g for VR renders).
- tip: call and read the ShowTestWindow() code in imgui_demo.cpp for more example of how to use ImGui!
ISSUES & TODO-LIST
==================
Issue numbers (#) refer to github issues listed at https://github.com/ocornut/imgui/issues
The list below consist mostly of notes of things to do before they are requested/discussed by users (at that point it usually happens on the github)
- doc: add a proper documentation+regression testing system (#435)
- window: maximum window size settings (per-axis). for large popups in particular user may not want the popup to fill all space.
- window: add a way for very transient windows (non-saved, temporary overlay over hundreds of objects) to "clean" up from the global window list. perhaps a lightweight explicit cleanup pass.
- window: calling SetNextWindowSize() every frame with <= 0 doesn't do anything, may be useful to allow (particularly when used for a single axis).
- window: auto-fit feedback loop when user relies on any dynamic layout (window width multiplier, column) appears weird to end-user. clarify.
- window: allow resizing of child windows (possibly given min/max for each axis?)
- window: background options for child windows, border option (disable rounding)
- window: add a way to clear an existing window instead of appending (e.g. for tooltip override using a consistent api rather than the deferred tooltip)
- window: resizing from any sides? + mouse cursor directives for app.
!- window: begin with *p_opened == false should return false.
- window: get size/pos helpers given names (see discussion in #249)
- window: a collapsed window can be stuck behind the main menu bar?
- window: when window is small, prioritize resize button over close button.
- window: detect extra End() call that pop the "Debug" window out and assert at call site instead of later.
- window/tooltip: allow to set the width of a tooltip to allow TextWrapped() etc. while keeping the height automatic.
- window: increase minimum size of a window with menus or fix the menu rendering so that it doesn't look odd.
- draw-list: maintaining bounding box per command would allow to merge draw command when clipping isn't relied on (typical non-scrolling window or non-overflowing column would merge with previous command).
!- scrolling: allow immediately effective change of scroll if we haven't appended items yet
- splitter/separator: formalize the splitter idiom into an official api (we want to handle n-way split) (#319)
- widgets: display mode: widget-label, label-widget (aligned on column or using fixed size), label-newline-tab-widget etc.
- widgets: clean up widgets internal toward exposing everything.
- widgets: add disabled and read-only modes (#211)
- main: considering adding an Init() function? some constructs are awkward in the implementation because of the lack of them.
!- main: make it so that a frame with no window registered won't refocus every window on subsequent frames (~bump LastFrameActive of all windows).
- main: IsItemHovered() make it more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes
- main: IsItemHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode?
- input text: clean up the mess caused by converting UTF-8 <> wchar. the code is rather inefficient right now.
- input text: reorganize event handling, allow CharFilter to modify buffers, allow multiple events? (#541)
- input text: flag to disable live update of the user buffer (also applies to float/int text input)
- input text: resize behavior - field could stretch when being edited? hover tooltip shows more text?
- input text: add ImGuiInputTextFlags_EnterToApply? (off #218)
- input text multi-line: don't directly call AddText() which does an unnecessary vertex reserve for character count prior to clipping. and/or more line-based clipping to AddText(). and/or reorganize TextUnformatted/RenderText for more efficiency for large text (e.g TextUnformatted could clip and log separately, etc).
- input text multi-line: way to dynamically grow the buffer without forcing the user to initially allocate for worse case (follow up on #200)
- input text multi-line: line numbers? status bar? (follow up on #200)
- input text: allow centering/positioning text so that ctrl+clicking Drag or Slider keeps the textual value at the same pixel position.
- input number: optional range min/max for Input*() functions
- input number: holding [-]/[+] buttons could increase the step speed non-linearly (or user-controlled)
- input number: use mouse wheel to step up/down
- input number: applying arithmetics ops (+,-,*,/) messes up with text edit undo stack.
- button: provide a button that looks framed.
- text: proper alignment options
- image/image button: misalignment on padded/bordered button?
- image/image button: parameters are confusing, image() has tint_col,border_col whereas imagebutton() has bg_col/tint_col. Even thou they are different parameters ordering could be more consistent. can we fix that?
- layout: horizontal layout helper (#97)
- layout: horizontal flow until no space left (#404)
- layout: more generic alignment state (left/right/centered) for single items?
- layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 layout code. item width should include frame padding.
- layout: BeginGroup() needs a border option.
- columns: declare column set (each column: fixed size, %, fill, distribute default size among fills) (#513, #125)
- columns: add a conditional parameter to SetColumnOffset() (#513, #125)
- columns: separator function or parameter that works within the column (currently Separator() bypass all columns) (#125)
- columns: columns header to act as button (~sort op) and allow resize/reorder (#513, #125)
- columns: user specify columns size (#513, #125)
- columns: flag to add horizontal separator above/below?
- columns/layout: setup minimum line height (equivalent of automatically calling AlignFirstTextHeightToWidgets)
- combo: sparse combo boxes (via function call?) / iterators
- combo: contents should extends to fit label if combo widget is small
- combo/listbox: keyboard control. need InputText-like non-active focus + key handling. considering keyboard for custom listbox (pr #203)
- listbox: multiple selection
- listbox: user may want to initial scroll to focus on the one selected value?
- listbox: keyboard navigation.
- listbox: scrolling should track modified selection.
!- popups/menus: clarify usage of popups id, how MenuItem/Selectable closing parent popups affects the ID, etc. this is quite fishy needs improvement! (#331, #402)
- popups: add variant using global identifier similar to Begin/End (#402)
- popups: border options. richer api like BeginChild() perhaps? (#197)
- tooltip: tooltip that doesn't fit in entire screen seems to lose their "last prefered button" and may teleport when moving mouse
- menus: local shortcuts, global shortcuts (#456, #126)
- menus: icons
- menus: menubars: some sort of priority / effect of main menu-bar on desktop size?
- menus: calling BeginMenu() twice with a same name doesn't seem to append nicely
- statusbar: add a per-window status bar helper similar to what menubar does.
- tabs (#261, #351)
- separator: separator on the initial position of a window is not visible (cursorpos.y <= clippos.y)
!- color: the color helpers/typing is a mess and needs sorting out.
- color: add a better color picker (#346)
- node/graph editor (#306)
- pie menus patterns (#434)
- drag'n drop, dragging helpers (carry dragging info, visualize drag source before clicking, drop target, etc.) (#143, #479)
- plot: PlotLines() should use the polygon-stroke facilities (currently issues with averaging normals)
- plot: make it easier for user to draw extra stuff into the graph (e.g: draw basis, highlight certain points, 2d plots, multiple plots)
- plot: "smooth" automatic scale over time, user give an input 0.0(full user scale) 1.0(full derived from value)
- plot: add a helper e.g. Plot(char* label, float value, float time_span=2.0f) that stores values and Plot them for you - probably another function name. and/or automatically allow to plot ANY displayed value (more reliance on stable ID)
- slider: allow using the [-]/[+] buttons used by InputFloat()/InputInt()
- slider: initial absolute click is imprecise. change to relative movement slider (same as scrollbar).
- slider: add dragging-based widgets to edit values with mouse (on 2 axises), saving screen real-estate.
- slider: tint background based on value (e.g. v_min -> v_max, or use 0.0f either side of the sign)
- slider & drag: int data passing through a float
- drag float: up/down axis
- drag float: added leeway on edge (e.g. a few invisible steps past the clamp limits)
- tree node / optimization: avoid formatting when clipped.
- tree node: clarify spacing, perhaps provide API to query exact spacing. provide API to draw the primitive. same with Bullet().
- tree node: tree-node/header right-most side doesn't take account of horizontal scrolling.
- tree node: add treenode/treepush int variants? because (void*) cast from int warns on some platforms/settings
- tree node: try to apply scrolling at time of TreePop() if node was just opened and end of node is past scrolling limits?
- tree node / selectable render mismatch which is visible if you use them both next to each other (e.g. cf. property viewer)
- textwrapped: figure out better way to use TextWrapped() in an always auto-resize context (tooltip, etc.) (git issue #249)
- settings: write more decent code to allow saving/loading new fields
- settings: api for per-tool simple persistent data (bool,int,float,columns sizes,etc.) in .ini file
- style: add window shadows.
- style/optimization: store rounded corners in texture to use 1 quad per corner (filled and wireframe) to lower the cost of rounding.
- style: color-box not always square?
- style: a concept of "compact style" that the end-user can easily rely on (e.g. PushStyleCompact()?) that maps to other settings? avoid implementing duplicate helpers such as SmallCheckbox(), etc.
- style: try to make PushStyleVar() more robust to incorrect parameters (to be more friendly to edit & continues situation).
- style/opt: PopStyleVar could be optimized by having GetStyleVar returns the type, using a table mapping stylevar enum to data type.
- style: global scale setting.
- style: WindowPadding needs to be EVEN needs the 0.5 multiplier probably have a subtle effect on clip rectangle
- text: simple markup language for color change?
- font: dynamic font atlas to avoid baking huge ranges into bitmap and make scaling easier.
- font: helper to add glyph redirect/replacements (e.g. redirect alternate apostrophe unicode code points to ascii one, etc.)
- log: LogButtons() options for specifying depth and/or hiding depth slider
- log: have more control over the log scope (e.g. stop logging when leaving current tree node scope)
- log: be able to log anything (e.g. right-click on a window/tree-node, shows context menu? log into tty/file/clipboard)
- log: let user copy any window content to clipboard easily (CTRL+C on windows? while moving it? context menu?). code is commented because it fails with multiple Begin/End pairs.
- filters: set a current filter that tree node can automatically query to hide themselves
- filters: handle wildcards (with implicit leading/trailing *), regexps
- shortcuts: add a shortcut api, e.g. parse "&Save" and/or "Save (CTRL+S)", pass in to widgets or provide simple ways to use (button=activate, input=focus)
!- keyboard: tooltip & combo boxes are messing up / not honoring keyboard tabbing
- keyboard: full keyboard navigation and focus. (#323)
- focus: SetKeyboardFocusHere() on with >= 0 offset could be done on same frame (else latch and modulate on beginning of next frame)
- input: rework IO system to be able to pass actual ordered/timestamped events.
- input: allow to decide and pass explicit double-clicks (e.g. for windows by the CS_DBLCLKS style).
- input: support track pad style scrolling & slider edit.
- misc: provide a way to compile out the entire implementation while providing a dummy API (e.g. #define IMGUI_DUMMY_IMPL)
- misc: double-clicking on title bar to minimize isn't consistent, perhaps move to single-click on left-most collapse icon?
- misc: provide HoveredTime and ActivatedTime to ease the creation of animations.
- style editor: have a more global HSV setter (e.g. alter hue on all elements). consider replacing active/hovered by offset in HSV space? (#438)
- style editor: color child window height expressed in multiple of line height.
- remote: make a system like RemoteImGui first-class citizen/project (#75)
!- demo: custom render demo pushes a clipping rectangle past parent window bounds. expose ImGui::PushClipRect() from imgui_internal.h?
- drawlist: end-user probably can't call Clear() directly because we expect a texture to be pushed in the stack.
- examples: directx9: save/restore device state more thoroughly.
- examples: window minimize, maximize (#583)
- optimization: use another hash function than crc32, e.g. FNV1a
- optimization/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)?
- optimization: turn some the various stack vectors into statically-sized arrays
- optimization: better clipping for multi-component widgets
*/
#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "imgui.h"
#define IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_PLACEMENT_NEW
#include "imgui_internal.h"
#include <ctype.h> // toupper, isprint
#include <math.h> // sqrtf, fabsf, fmodf, powf, cosf, sinf, floorf, ceilf
#include <stdlib.h> // NULL, malloc, free, qsort, atoi
#include <stdio.h> // vsnprintf, sscanf, printf
#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier
#include <stddef.h> // intptr_t
#else
#include <stdint.h> // intptr_t
#endif
#ifdef _MSC_VER
#pragma warning (disable: 4127) // condition expression is constant
#pragma warning (disable: 4505) // unreferenced local function has been removed (stb stuff)
#pragma warning (disable: 4996) // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen
#define snprintf _snprintf
#endif
// Clang warnings with -Weverything
#ifdef __clang__
#pragma clang diagnostic ignored "-Wold-style-cast" // warning : use of old-style cast // yes, they are more terse.
#pragma clang diagnostic ignored "-Wfloat-equal" // warning : comparing floating point with == or != is unsafe // storing and comparing against same constants ok.
#pragma clang diagnostic ignored "-Wformat-nonliteral" // warning : format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.
#pragma clang diagnostic ignored "-Wexit-time-destructors" // warning : declaration requires an exit-time destructor // exit-time destruction order is undefined. if MemFree() leads to users code that has been disabled before exit it might cause problems. ImGui coding style welcomes static/globals.
#pragma clang diagnostic ignored "-Wglobal-constructors" // warning : declaration requires a global destructor // similar to above, not sure what the exact difference it.
#pragma clang diagnostic ignored "-Wsign-conversion" // warning : implicit conversion changes signedness //
#pragma clang diagnostic ignored "-Wmissing-noreturn" // warning : function xx could be declared with attribute 'noreturn' warning // GetDefaultFontData() asserts which some implementation makes it never return.
#pragma clang diagnostic ignored "-Wdeprecated-declarations"// warning : 'xx' is deprecated: The POSIX name for this item.. // for strdup used in demo code (so user can copy & paste the code)
#pragma clang diagnostic ignored "-Wint-to-void-pointer-cast" // warning : cast to 'void *' from smaller integer type 'int'
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-function" // warning: 'xxxx' defined but not used
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast" // warning: cast to pointer from integer of different size
#endif
//-------------------------------------------------------------------------
// Forward Declarations
//-------------------------------------------------------------------------
static void LogRenderedText(const ImVec2& ref_pos, const char* text, const char* text_end = NULL);
static void PushMultiItemsWidths(int components, float w_full = 0.0f);
static float GetDraggedColumnOffset(int column_index);
static bool IsKeyPressedMap(ImGuiKey key, bool repeat = true);
static void SetCurrentFont(ImFont* font);
static void SetCurrentWindow(ImGuiWindow* window);
static void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y);
static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond);
static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond);
static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond);
static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs);
static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags);
static inline bool IsWindowContentHoverable(ImGuiWindow* window);
static void ClearSetNextWindowData();
static void CheckStacksSize(ImGuiWindow* window, bool write);
static void Scrollbar(ImGuiWindow* window, bool horizontal);
static bool CloseWindowButton(bool* p_opened);
static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list);
static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window);
static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window);
static ImGuiIniData* FindWindowSettings(const char* name);
static ImGuiIniData* AddWindowSettings(const char* name);
static void LoadSettings();
static void SaveSettings();
static void MarkSettingsDirty();
static void PushColumnClipRect(int column_index = -1);
static ImRect GetVisibleRect();
static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags);
static void CloseInactivePopups();
static void ClosePopupToLevel(int remaining);
static void ClosePopup(ImGuiID id);
static bool IsPopupOpen(ImGuiID id);
static ImGuiWindow* GetFrontMostModalRootWindow();
static ImVec2 FindBestPopupWindowPos(const ImVec2& base_pos, const ImVec2& size, int* last_dir, const ImRect& rect_to_avoid);
static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data);
static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end);
static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL, ImVec2* out_offset = NULL, bool stop_on_new_line = false);
static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, const char* display_format, char* buf, int buf_size);
static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, int decimal_precision, char* buf, int buf_size);
static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* value1, const void* value2);
static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* data_ptr, const char* scalar_format);
//-----------------------------------------------------------------------------
// Platform dependent default implementations
//-----------------------------------------------------------------------------
static const char* GetClipboardTextFn_DefaultImpl();
static void SetClipboardTextFn_DefaultImpl(const char* text);
static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y);
//-----------------------------------------------------------------------------
// Context
//-----------------------------------------------------------------------------
// We access everything through this pointer (always assumed to be != NULL)
// You can swap the pointer to a different context by calling ImGui::SetInternalState()
static ImGuiState GImDefaultState;
ImGuiState* GImGui = &GImDefaultState;
// Statically allocated default font atlas. This is merely a maneuver to keep ImFontAtlas definition at the bottom of the .h file (otherwise it'd be inside ImGuiIO)
// Also we wouldn't be able to new() one at this point, before users may define IO.MemAllocFn.
static ImFontAtlas GImDefaultFontAtlas;
//-----------------------------------------------------------------------------
// User facing structures
//-----------------------------------------------------------------------------
ImGuiStyle::ImGuiStyle()
{
Alpha = 1.0f; // Global alpha applies to everything in ImGui
WindowPadding = ImVec2(8,8); // Padding within a window
WindowMinSize = ImVec2(32,32); // Minimum window size
WindowRounding = 9.0f; // Radius of window corners rounding. Set to 0.0f to have rectangular windows
WindowTitleAlign = ImGuiAlign_Left; // Alignment for title bar text
ChildWindowRounding = 0.0f; // Radius of child window corners rounding. Set to 0.0f to have rectangular child windows
FramePadding = ImVec2(4,3); // Padding within a framed rectangle (used by most widgets)
FrameRounding = 0.0f; // Radius of frame corners rounding. Set to 0.0f to have rectangular frames (used by most widgets).
ItemSpacing = ImVec2(8,4); // Horizontal and vertical spacing between widgets/lines
ItemInnerSpacing = ImVec2(4,4); // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
TouchExtraPadding = ImVec2(0,0); // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
IndentSpacing = 22.0f; // Horizontal spacing when e.g. entering a tree node
ColumnsMinSpacing = 6.0f; // Minimum horizontal spacing between two columns
ScrollbarSize = 16.0f; // Width of the vertical scrollbar, Height of the horizontal scrollbar
ScrollbarRounding = 9.0f; // Radius of grab corners rounding for scrollbar
GrabMinSize = 10.0f; // Minimum width/height of a grab box for slider/scrollbar
GrabRounding = 0.0f; // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
DisplayWindowPadding = ImVec2(22,22); // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.
DisplaySafeAreaPadding = ImVec2(4,4); // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.
AntiAliasedLines = true; // Enable anti-aliasing on lines/borders. Disable if you are really short on CPU/GPU.
AntiAliasedShapes = true; // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
CurveTessellationTol = 1.25f; // Tessellation tolerance. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
Colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
Colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.70f);
Colors[ImGuiCol_ChildWindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
Colors[ImGuiCol_PopupBg] = ImVec4(0.05f, 0.05f, 0.10f, 0.90f);
Colors[ImGuiCol_Border] = ImVec4(0.70f, 0.70f, 0.70f, 0.65f);
Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
Colors[ImGuiCol_FrameBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.30f); // Background of checkbox, radio button, plot, slider, text input
Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.90f, 0.80f, 0.80f, 0.40f);
Colors[ImGuiCol_FrameBgActive] = ImVec4(0.90f, 0.65f, 0.65f, 0.45f);
Colors[ImGuiCol_TitleBg] = ImVec4(0.50f, 0.50f, 1.00f, 0.45f);
Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);
Colors[ImGuiCol_TitleBgActive] = ImVec4(0.50f, 0.50f, 1.00f, 0.55f);
Colors[ImGuiCol_MenuBarBg] = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);
Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.20f, 0.25f, 0.30f, 0.60f);
Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);
Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);
Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.80f, 0.50f, 0.50f, 0.40f);
Colors[ImGuiCol_ComboBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.99f);
Colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);
Colors[ImGuiCol_SliderGrab] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f);
Colors[ImGuiCol_Button] = ImVec4(0.67f, 0.40f, 0.40f, 0.60f);
Colors[ImGuiCol_ButtonHovered] = ImVec4(0.67f, 0.40f, 0.40f, 1.00f);
Colors[ImGuiCol_ButtonActive] = ImVec4(0.80f, 0.50f, 0.50f, 1.00f);
Colors[ImGuiCol_Header] = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);
Colors[ImGuiCol_HeaderHovered] = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);
Colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);
Colors[ImGuiCol_Column] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
Colors[ImGuiCol_ColumnHovered] = ImVec4(0.70f, 0.60f, 0.60f, 1.00f);
Colors[ImGuiCol_ColumnActive] = ImVec4(0.90f, 0.70f, 0.70f, 1.00f);
Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
Colors[ImGuiCol_ResizeGripHovered] = ImVec4(1.00f, 1.00f, 1.00f, 0.60f);
Colors[ImGuiCol_ResizeGripActive] = ImVec4(1.00f, 1.00f, 1.00f, 0.90f);
Colors[ImGuiCol_CloseButton] = ImVec4(0.50f, 0.50f, 0.90f, 0.50f);
Colors[ImGuiCol_CloseButtonHovered] = ImVec4(0.70f, 0.70f, 0.90f, 0.60f);
Colors[ImGuiCol_CloseButtonActive] = ImVec4(0.70f, 0.70f, 0.70f, 1.00f);
Colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
Colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
Colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);
Colors[ImGuiCol_ModalWindowDarkening] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
}
ImGuiIO::ImGuiIO()
{
// Most fields are initialized with zero
memset(this, 0, sizeof(*this));
DisplaySize = ImVec2(-1.0f, -1.0f);
DeltaTime = 1.0f/60.0f;
IniSavingRate = 5.0f;
IniFilename = "imgui.ini";
LogFilename = "imgui_log.txt";
Fonts = &GImDefaultFontAtlas;
FontGlobalScale = 1.0f;
DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
MousePos = ImVec2(-1,-1);
MousePosPrev = ImVec2(-1,-1);
MouseDoubleClickTime = 0.30f;
MouseDoubleClickMaxDist = 6.0f;
MouseDragThreshold = 6.0f;
for (int i = 0; i < IM_ARRAYSIZE(MouseDownDuration); i++)
MouseDownDuration[i] = MouseDownDurationPrev[i] = -1.0f;
for (int i = 0; i < IM_ARRAYSIZE(KeysDownDuration); i++)
KeysDownDuration[i] = KeysDownDurationPrev[i] = -1.0f;
for (int i = 0; i < ImGuiKey_COUNT; i++)
KeyMap[i] = -1;
KeyRepeatDelay = 0.250f;
KeyRepeatRate = 0.050f;
UserData = NULL;
// User functions
RenderDrawListsFn = NULL;
MemAllocFn = malloc;
MemFreeFn = free;
GetClipboardTextFn = GetClipboardTextFn_DefaultImpl; // Platform dependent default implementations
SetClipboardTextFn = SetClipboardTextFn_DefaultImpl;
ImeSetInputScreenPosFn = ImeSetInputScreenPosFn_DefaultImpl;
// Set OS X style defaults based on __APPLE__ compile time flag
#ifdef __APPLE__
WordMovementUsesAltKey = true; // OS X style: Text editing cursor movement using Alt instead of Ctrl
ShortcutsUseSuperKey = true; // OS X style: Shortcuts using Cmd/Super instead of Ctrl
DoubleClickSelectsWord = true; // OS X style: Double click selects by word instead of selecting whole text
MultiSelectUsesSuperKey = true; // OS X style: Multi-selection in lists uses Cmd/Super instead of Ctrl
#endif
}
// Pass in translated ASCII characters for text input.
// - with glfw you can get those from the callback set in glfwSetCharCallback()
// - on Windows you can get those using ToAscii+keyboard state, or via the WM_CHAR message
void ImGuiIO::AddInputCharacter(ImWchar c)
{
const int n = ImStrlenW(InputCharacters);
if (n + 1 < IM_ARRAYSIZE(InputCharacters))
{
InputCharacters[n] = c;
InputCharacters[n+1] = '\0';
}
}
void ImGuiIO::AddInputCharactersUTF8(const char* utf8_chars)
{
// We can't pass more wchars than ImGuiIO::InputCharacters[] can hold so don't convert more
const int wchars_buf_len = sizeof(ImGuiIO::InputCharacters) / sizeof(ImWchar);
ImWchar wchars[wchars_buf_len];
ImTextStrFromUtf8(wchars, wchars_buf_len, utf8_chars, NULL);
for (int i = 0; i < wchars_buf_len && wchars[i] != 0; i++)
AddInputCharacter(wchars[i]);
}
//-----------------------------------------------------------------------------
// HELPERS
//-----------------------------------------------------------------------------
#define IM_F32_TO_INT8(_VAL) ((int)((_VAL) * 255.0f + 0.5f))
#define IM_INT_MIN (-2147483647-1)
#define IM_INT_MAX (2147483647)
// Play it nice with Windows users. Notepad in 2015 still doesn't display text data with Unix-style \n.
#ifdef _WIN32
#define IM_NEWLINE "\r\n"
#else
#define IM_NEWLINE "\n"
#endif
bool ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c)
{
bool b1 = ((p.x - b.x) * (a.y - b.y) - (p.y - b.y) * (a.x - b.x)) < 0.0f;
bool b2 = ((p.x - c.x) * (b.y - c.y) - (p.y - c.y) * (b.x - c.x)) < 0.0f;
bool b3 = ((p.x - a.x) * (c.y - a.y) - (p.y - a.y) * (c.x - a.x)) < 0.0f;
return ((b1 == b2) && (b2 == b3));
}
int ImStricmp(const char* str1, const char* str2)
{
int d;
while ((d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; }
return d;
}
int ImStrnicmp(const char* str1, const char* str2, int count)
{
int d = 0;
while (count > 0 && (d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; count--; }
return d;
}
char* ImStrdup(const char *str)
{
size_t len = strlen(str) + 1;
void* buff = ImGui::MemAlloc(len);
return (char*)memcpy(buff, (const void*)str, len);
}
int ImStrlenW(const ImWchar* str)
{
int n = 0;
while (*str++) n++;
return n;
}
const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin) // find beginning-of-line
{
while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')
buf_mid_line--;
return buf_mid_line;
}
const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end)
{
if (!needle_end)
needle_end = needle + strlen(needle);
const char un0 = (char)toupper(*needle);
while ((!haystack_end && *haystack) || (haystack_end && haystack < haystack_end))
{
if (toupper(*haystack) == un0)
{
const char* b = needle + 1;
for (const char* a = haystack + 1; b < needle_end; a++, b++)
if (toupper(*a) != toupper(*b))
break;
if (b == needle_end)
return haystack;
}
haystack++;
}
return NULL;
}
int ImFormatString(char* buf, int buf_size, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
int w = vsnprintf(buf, buf_size, fmt, args);
va_end(args);
buf[buf_size-1] = 0;
return (w == -1) ? buf_size : w;
}
int ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args)
{
int w = vsnprintf(buf, buf_size, fmt, args);
buf[buf_size-1] = 0;
return (w == -1) ? buf_size : w;
}
// Pass data_size==0 for zero-terminated strings
// FIXME-OPT: Replace with e.g. FNV1a hash? CRC32 pretty much randomly access 1KB. Need to do proper measurements.
ImU32 ImHash(const void* data, int data_size, ImU32 seed)
{
static ImU32 crc32_lut[256] = { 0 };
if (!crc32_lut[1])
{
const ImU32 polynomial = 0xEDB88320;
for (ImU32 i = 0; i < 256; i++)
{
ImU32 crc = i;
for (ImU32 j = 0; j < 8; j++)
crc = (crc >> 1) ^ (ImU32(-int(crc & 1)) & polynomial);
crc32_lut[i] = crc;
}
}
seed = ~seed;
ImU32 crc = seed;
const unsigned char* current = (const unsigned char*)data;
if (data_size > 0)
{
// Known size
while (data_size--)
crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *current++];
}
else
{
// Zero-terminated string
while (unsigned char c = *current++)
{
// We support a syntax of "label###id" where only "###id" is included in the hash, and only "label" gets displayed.
// Because this syntax is rarely used we are optimizing for the common case.
// - If we reach ### in the string we discard the hash so far and reset to the seed.
// - We don't do 'current += 2; continue;' after handling ### to keep the code smaller.
if (c == '#' && current[0] == '#' && current[1] == '#')
crc = seed;
crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];
}
}
return ~crc;
}
//-----------------------------------------------------------------------------
// ImText* helpers
//-----------------------------------------------------------------------------
// Convert UTF-8 to 32-bits character, process single character input.
// Based on stb_from_utf8() from github.com/nothings/stb/
// We handle UTF-8 decoding error by skipping forward.
int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end)
{
unsigned int c = (unsigned int)-1;
const unsigned char* str = (const unsigned char*)in_text;
if (!(*str & 0x80))
{
c = (unsigned int)(*str++);
*out_char = c;
return 1;
}
if ((*str & 0xe0) == 0xc0)
{
*out_char = 0xFFFD; // will be invalid but not end of string
if (in_text_end && in_text_end - (const char*)str < 2) return 1;
if (*str < 0xc2) return 2;
c = (unsigned int)((*str++ & 0x1f) << 6);
if ((*str & 0xc0) != 0x80) return 2;
c += (*str++ & 0x3f);
*out_char = c;
return 2;
}
if ((*str & 0xf0) == 0xe0)
{
*out_char = 0xFFFD; // will be invalid but not end of string
if (in_text_end && in_text_end - (const char*)str < 3) return 1;
if (*str == 0xe0 && (str[1] < 0xa0 || str[1] > 0xbf)) return 3;
if (*str == 0xed && str[1] > 0x9f) return 3; // str[1] < 0x80 is checked below
c = (unsigned int)((*str++ & 0x0f) << 12);
if ((*str & 0xc0) != 0x80) return 3;
c += (unsigned int)((*str++ & 0x3f) << 6);
if ((*str & 0xc0) != 0x80) return 3;
c += (*str++ & 0x3f);
*out_char = c;
return 3;
}
if ((*str & 0xf8) == 0xf0)
{
*out_char = 0xFFFD; // will be invalid but not end of string
if (in_text_end && in_text_end - (const char*)str < 4) return 1;
if (*str > 0xf4) return 4;
if (*str == 0xf0 && (str[1] < 0x90 || str[1] > 0xbf)) return 4;
if (*str == 0xf4 && str[1] > 0x8f) return 4; // str[1] < 0x80 is checked below
c = (unsigned int)((*str++ & 0x07) << 18);
if ((*str & 0xc0) != 0x80) return 4;
c += (unsigned int)((*str++ & 0x3f) << 12);
if ((*str & 0xc0) != 0x80) return 4;
c += (unsigned int)((*str++ & 0x3f) << 6);
if ((*str & 0xc0) != 0x80) return 4;
c += (*str++ & 0x3f);
// utf-8 encodings of values used in surrogate pairs are invalid
if ((c & 0xFFFFF800) == 0xD800) return 4;
*out_char = c;
return 4;
}
*out_char = 0;
return 0;
}
int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_text_remaining)
{
ImWchar* buf_out = buf;
ImWchar* buf_end = buf + buf_size;
while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c;
in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
if (c == 0)
break;
if (c < 0x10000) // FIXME: Losing characters that don't fit in 2 bytes
*buf_out++ = (ImWchar)c;
}
*buf_out = 0;
if (in_text_remaining)
*in_text_remaining = in_text;
return (int)(buf_out - buf);
}
int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)
{
int char_count = 0;
while ((!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c;
in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
if (c == 0)
break;
if (c < 0x10000)
char_count++;
}
return char_count;
}
// Based on stb_to_utf8() from github.com/nothings/stb/
static inline int ImTextCharToUtf8(char* buf, int buf_size, unsigned int c)
{
if (c < 0x80)
{
buf[0] = (char)c;
return 1;
}
if (c < 0x800)
{
if (buf_size < 2) return 0;
buf[0] = (char)(0xc0 + (c >> 6));
buf[1] = (char)(0x80 + (c & 0x3f));
return 2;
}
if (c >= 0xdc00 && c < 0xe000)
{
return 0;
}
if (c >= 0xd800 && c < 0xdc00)
{
if (buf_size < 4) return 0;
buf[0] = (char)(0xf0 + (c >> 18));
buf[1] = (char)(0x80 + ((c >> 12) & 0x3f));
buf[2] = (char)(0x80 + ((c >> 6) & 0x3f));
buf[3] = (char)(0x80 + ((c ) & 0x3f));
return 4;
}
//else if (c < 0x10000)
{
if (buf_size < 3) return 0;
buf[0] = (char)(0xe0 + (c >> 12));
buf[1] = (char)(0x80 + ((c>> 6) & 0x3f));
buf[2] = (char)(0x80 + ((c ) & 0x3f));
return 3;
}
}
static inline int ImTextCountUtf8BytesFromChar(unsigned int c)
{
if (c < 0x80) return 1;
if (c < 0x800) return 2;
if (c >= 0xdc00 && c < 0xe000) return 0;
if (c >= 0xd800 && c < 0xdc00) return 4;
return 3;
}
int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
char* buf_out = buf;
const char* buf_end = buf + buf_size;
while (buf_out < buf_end-1 && (!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c = (unsigned int)(*in_text++);
if (c < 0x80)
*buf_out++ = (char)c;
else
buf_out += ImTextCharToUtf8(buf_out, (int)(buf_end-buf_out-1), c);
}
*buf_out = 0;
return (int)(buf_out - buf);
}
int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end)
{
int bytes_count = 0;
while ((!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c = (unsigned int)(*in_text++);
if (c < 0x80)
bytes_count++;
else
bytes_count += ImTextCountUtf8BytesFromChar(c);
}
return bytes_count;
}
ImVec4 ImGui::ColorConvertU32ToFloat4(ImU32 in)
{
float s = 1.0f/255.0f;
return ImVec4((in & 0xFF) * s, ((in >> 8) & 0xFF) * s, ((in >> 16) & 0xFF) * s, (in >> 24) * s);
}
ImU32 ImGui::ColorConvertFloat4ToU32(const ImVec4& in)
{
ImU32 out;
out = ((ImU32)IM_F32_TO_INT8(ImSaturate(in.x)));
out |= ((ImU32)IM_F32_TO_INT8(ImSaturate(in.y))) << 8;
out |= ((ImU32)IM_F32_TO_INT8(ImSaturate(in.z))) << 16;
out |= ((ImU32)IM_F32_TO_INT8(ImSaturate(in.w))) << 24;
return out;
}
// Convert rgb floats ([0-1],[0-1],[0-1]) to hsv floats ([0-1],[0-1],[0-1]), from Foley & van Dam p592
// Optimized http://lolengine.net/blog/2013/01/13/fast-rgb-to-hsv
void ImGui::ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v)
{
float K = 0.f;
if (g < b)
{
const float tmp = g; g = b; b = tmp;
K = -1.f;
}
if (r < g)
{
const float tmp = r; r = g; g = tmp;
K = -2.f / 6.f - K;
}
const float chroma = r - (g < b ? g : b);
out_h = fabsf(K + (g - b) / (6.f * chroma + 1e-20f));
out_s = chroma / (r + 1e-20f);
out_v = r;
}
// Convert hsv floats ([0-1],[0-1],[0-1]) to rgb floats ([0-1],[0-1],[0-1]), from Foley & van Dam p593
// also http://en.wikipedia.org/wiki/HSL_and_HSV
void ImGui::ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b)
{
if (s == 0.0f)
{
// gray
out_r = out_g = out_b = v;
return;
}
h = fmodf(h, 1.0f) / (60.0f/360.0f);
int i = (int)h;
float f = h - (float)i;
float p = v * (1.0f - s);
float q = v * (1.0f - s * f);
float t = v * (1.0f - s * (1.0f - f));
switch (i)
{
case 0: out_r = v; out_g = t; out_b = p; break;
case 1: out_r = q; out_g = v; out_b = p; break;
case 2: out_r = p; out_g = v; out_b = t; break;
case 3: out_r = p; out_g = q; out_b = v; break;
case 4: out_r = t; out_g = p; out_b = v; break;
case 5: default: out_r = v; out_g = p; out_b = q; break;
}
}
// Load file content into memory
// Memory allocated with ImGui::MemAlloc(), must be freed by user using ImGui::MemFree()
void* ImLoadFileToMemory(const char* filename, const char* file_open_mode, int* out_file_size, int padding_bytes)
{
IM_ASSERT(filename && file_open_mode);
if (out_file_size)
*out_file_size = 0;
FILE* f;
if ((f = fopen(filename, file_open_mode)) == NULL)
return NULL;
long file_size_signed;
if (fseek(f, 0, SEEK_END) || (file_size_signed = ftell(f)) == -1 || fseek(f, 0, SEEK_SET))
{
fclose(f);
return NULL;
}
int file_size = (int)file_size_signed;
void* file_data = ImGui::MemAlloc(file_size + padding_bytes);
if (file_data == NULL)
{
fclose(f);
return NULL;
}
if (fread(file_data, 1, (size_t)file_size, f) != (size_t)file_size)
{
fclose(f);
ImGui::MemFree(file_data);
return NULL;
}
if (padding_bytes > 0)
memset((void *)(((char*)file_data) + file_size), 0, padding_bytes);
fclose(f);
if (out_file_size)
*out_file_size = file_size;
return file_data;
}
//-----------------------------------------------------------------------------
// ImGuiStorage
//-----------------------------------------------------------------------------
// Helper: Key->value storage
void ImGuiStorage::Clear()
{
Data.clear();
}
// std::lower_bound but without the bullshit
static ImVector<ImGuiStorage::Pair>::iterator LowerBound(ImVector<ImGuiStorage::Pair>& data, ImU32 key)
{
ImVector<ImGuiStorage::Pair>::iterator first = data.begin();
ImVector<ImGuiStorage::Pair>::iterator last = data.end();
int count = (int)(last - first);
while (count > 0)
{
int count2 = count / 2;
ImVector<ImGuiStorage::Pair>::iterator mid = first + count2;
if (mid->key < key)
{
first = ++mid;
count -= count2 + 1;
}
else
{
count = count2;
}
}
return first;
}
int ImGuiStorage::GetInt(ImU32 key, int default_val) const
{
ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
if (it == Data.end() || it->key != key)
return default_val;
return it->val_i;
}
float ImGuiStorage::GetFloat(ImU32 key, float default_val) const
{
ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
if (it == Data.end() || it->key != key)
return default_val;
return it->val_f;
}
void* ImGuiStorage::GetVoidPtr(ImGuiID key) const
{
ImVector<Pair>::iterator it = LowerBound(const_cast<ImVector<ImGuiStorage::Pair>&>(Data), key);
if (it == Data.end() || it->key != key)
return NULL;
return it->val_p;
}
// References are only valid until a new value is added to the storage. Calling a Set***() function or a Get***Ref() function invalidates the pointer.
int* ImGuiStorage::GetIntRef(ImGuiID key, int default_val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, Pair(key, default_val));
return &it->val_i;
}
float* ImGuiStorage::GetFloatRef(ImGuiID key, float default_val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, Pair(key, default_val));
return &it->val_f;
}
void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, Pair(key, default_val));
return &it->val_p;
}
// FIXME-OPT: Need a way to reuse the result of lower_bound when doing GetInt()/SetInt() - not too bad because it only happens on explicit interaction (maximum one a frame)
void ImGuiStorage::SetInt(ImU32 key, int val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
{
Data.insert(it, Pair(key, val));
return;
}
it->val_i = val;
}
void ImGuiStorage::SetFloat(ImU32 key, float val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
{
Data.insert(it, Pair(key, val));
return;
}
it->val_f = val;
}
void ImGuiStorage::SetVoidPtr(ImU32 key, void* val)
{
ImVector<Pair>::iterator it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
{
Data.insert(it, Pair(key, val));
return;
}
it->val_p = val;
}
void ImGuiStorage::SetAllInt(int v)
{
for (int i = 0; i < Data.Size; i++)
Data[i].val_i = v;
}
//-----------------------------------------------------------------------------
// ImGuiTextFilter
//-----------------------------------------------------------------------------
// Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
ImGuiTextFilter::ImGuiTextFilter(const char* default_filter)
{
if (default_filter)
{
ImFormatString(InputBuf, IM_ARRAYSIZE(InputBuf), "%s", default_filter);
Build();
}
else
{
InputBuf[0] = 0;
CountGrep = 0;
}
}
bool ImGuiTextFilter::Draw(const char* label, float width)
{
if (width != 0.0f)
ImGui::PushItemWidth(width);
bool value_changed = ImGui::InputText(label, InputBuf, IM_ARRAYSIZE(InputBuf));
if (width != 0.0f)
ImGui::PopItemWidth();
if (value_changed)
Build();
return value_changed;
}
void ImGuiTextFilter::TextRange::split(char separator, ImVector<TextRange>& out)
{
out.resize(0);
const char* wb = b;
const char* we = wb;
while (we < e)
{
if (*we == separator)
{
out.push_back(TextRange(wb, we));
wb = we + 1;
}
we++;
}
if (wb != we)
out.push_back(TextRange(wb, we));
}
void ImGuiTextFilter::Build()
{
Filters.resize(0);
TextRange input_range(InputBuf, InputBuf+strlen(InputBuf));
input_range.split(',', Filters);
CountGrep = 0;
for (int i = 0; i != Filters.Size; i++)
{
Filters[i].trim_blanks();
if (Filters[i].empty())
continue;
if (Filters[i].front() != '-')
CountGrep += 1;
}
}
bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
if (Filters.empty())
return true;
if (text == NULL)
text = "";
for (int i = 0; i != Filters.Size; i++)
{
const TextRange& f = Filters[i];
if (f.empty())
continue;
if (f.front() == '-')
{
// Subtract
if (ImStristr(text, text_end, f.begin()+1, f.end()) != NULL)
return false;
}
else
{
// Grep
if (ImStristr(text, text_end, f.begin(), f.end()) != NULL)
return true;
}
}
// Implicit * grep
if (CountGrep == 0)
return true;
return false;
}
//-----------------------------------------------------------------------------
// ImGuiTextBuffer
//-----------------------------------------------------------------------------
// On some platform vsnprintf() takes va_list by reference and modifies it.
// va_copy is the 'correct' way to copy a va_list but Visual Studio prior to 2013 doesn't have it.
#ifndef va_copy
#define va_copy(dest, src) (dest = src)
#endif
// Helper: Text buffer for logging/accumulating text
void ImGuiTextBuffer::appendv(const char* fmt, va_list args)
{
va_list args_copy;
va_copy(args_copy, args);
int len = vsnprintf(NULL, 0, fmt, args); // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
if (len <= 0)
return;
const int write_off = Buf.Size;
const int needed_sz = write_off + len;
if (write_off + len >= Buf.Capacity)
{
int double_capacity = Buf.Capacity * 2;
Buf.reserve(needed_sz > double_capacity ? needed_sz : double_capacity);
}
Buf.resize(needed_sz);
ImFormatStringV(&Buf[write_off] - 1, len+1, fmt, args_copy);
}
void ImGuiTextBuffer::append(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
appendv(fmt, args);
va_end(args);
}
//-----------------------------------------------------------------------------
// ImGuiSimpleColumns
//-----------------------------------------------------------------------------
ImGuiSimpleColumns::ImGuiSimpleColumns()
{
Count = 0;
Spacing = Width = NextWidth = 0.0f;
memset(Pos, 0, sizeof(Pos));
memset(NextWidths, 0, sizeof(NextWidths));
}
void ImGuiSimpleColumns::Update(int count, float spacing, bool clear)
{
IM_ASSERT(Count <= IM_ARRAYSIZE(Pos));
Count = count;
Width = NextWidth = 0.0f;
Spacing = spacing;
if (clear) memset(NextWidths, 0, sizeof(NextWidths));
for (int i = 0; i < Count; i++)
{
if (i > 0 && NextWidths[i] > 0.0f)
Width += Spacing;
Pos[i] = (float)(int)Width;
Width += NextWidths[i];
NextWidths[i] = 0.0f;
}
}
float ImGuiSimpleColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
NextWidth = 0.0f;
NextWidths[0] = ImMax(NextWidths[0], w0);
NextWidths[1] = ImMax(NextWidths[1], w1);
NextWidths[2] = ImMax(NextWidths[2], w2);
for (int i = 0; i < 3; i++)
NextWidth += NextWidths[i] + ((i > 0 && NextWidths[i] > 0.0f) ? Spacing : 0.0f);
return ImMax(Width, NextWidth);
}
float ImGuiSimpleColumns::CalcExtraSpace(float avail_w)
{
return ImMax(0.0f, avail_w - Width);
}
//-----------------------------------------------------------------------------
// ImGuiWindow
//-----------------------------------------------------------------------------
ImGuiWindow::ImGuiWindow(const char* name)
{
Name = ImStrdup(name);
ID = ImHash(name, 0);
IDStack.push_back(ID);
MoveID = GetID("#MOVE");
Flags = 0;
PosFloat = Pos = ImVec2(0.0f, 0.0f);
Size = SizeFull = ImVec2(0.0f, 0.0f);
SizeContents = SizeContentsExplicit = ImVec2(0.0f, 0.0f);
WindowPadding = ImVec2(0.0f, 0.0f);
Scroll = ImVec2(0.0f, 0.0f);
ScrollTarget = ImVec2(FLT_MAX, FLT_MAX);
ScrollTargetCenterRatio = ImVec2(0.5f, 0.5f);
ScrollbarX = ScrollbarY = false;
ScrollbarSizes = ImVec2(0.0f, 0.0f);
BorderSize = 0.0f;
Active = WasActive = false;
Accessed = false;
Collapsed = false;
SkipItems = false;
BeginCount = 0;
PopupID = 0;
AutoFitFramesX = AutoFitFramesY = -1;
AutoFitOnlyGrows = false;
AutoPosLastDirection = -1;
HiddenFrames = 0;
SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = ImGuiSetCond_Always | ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing;
SetWindowPosCenterWanted = false;
LastFrameActive = -1;
ItemWidthDefault = 0.0f;
FontWindowScale = 1.0f;
DrawList = (ImDrawList*)ImGui::MemAlloc(sizeof(ImDrawList));
IM_PLACEMENT_NEW(DrawList) ImDrawList();
DrawList->_OwnerName = Name;
RootWindow = NULL;
RootNonPopupWindow = NULL;
FocusIdxAllCounter = FocusIdxTabCounter = -1;
FocusIdxAllRequestCurrent = FocusIdxTabRequestCurrent = IM_INT_MAX;
FocusIdxAllRequestNext = FocusIdxTabRequestNext = IM_INT_MAX;
}
ImGuiWindow::~ImGuiWindow()
{
DrawList->~ImDrawList();
ImGui::MemFree(DrawList);
DrawList = NULL;
ImGui::MemFree(Name);
Name = NULL;
}
ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
ImGuiID seed = IDStack.back();
ImGuiID id = ImHash(str, str_end ? (int)(str_end - str) : 0, seed);
ImGui::KeepAliveID(id);
return id;
}
ImGuiID ImGuiWindow::GetID(const void* ptr)
{
ImGuiID seed = IDStack.back();
ImGuiID id = ImHash(&ptr, sizeof(void*), seed);
ImGui::KeepAliveID(id);
return id;
}
//-----------------------------------------------------------------------------
// Internal API exposed in imgui_internal.h
//-----------------------------------------------------------------------------
static void SetCurrentWindow(ImGuiWindow* window)
{
ImGuiState& g = *GImGui;
g.CurrentWindow = window;
if (window)
g.FontSize = window->CalcFontSize();
}
ImGuiWindow* ImGui::GetParentWindow()
{
ImGuiState& g = *GImGui;
IM_ASSERT(g.CurrentWindowStack.Size >= 2);
return g.CurrentWindowStack[(unsigned int)g.CurrentWindowStack.Size - 2];
}
void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window = NULL)
{
ImGuiState& g = *GImGui;
g.ActiveId = id;
g.ActiveIdAllowOverlap = false;
g.ActiveIdIsJustActivated = true;
g.ActiveIdWindow = window;
}
void ImGui::SetHoveredID(ImGuiID id)
{
ImGuiState& g = *GImGui;
g.HoveredId = id;
g.HoveredIdAllowOverlap = false;
}
void ImGui::KeepAliveID(ImGuiID id)
{
ImGuiState& g = *GImGui;
if (g.ActiveId == id)
g.ActiveIdIsAlive = true;
}
// Advance cursor given item size for layout.
void ImGui::ItemSize(const ImVec2& size, float text_offset_y)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
// Always align ourselves on pixel boundaries
ImGuiState& g = *GImGui;
const float line_height = ImMax(window->DC.CurrentLineHeight, size.y);
const float text_base_offset = ImMax(window->DC.CurrentLineTextBaseOffset, text_offset_y);
window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y);
window->DC.CursorPos = ImVec2((float)(int)(window->Pos.x + window->DC.IndentX + window->DC.ColumnsOffsetX), (float)(int)(window->DC.CursorPos.y + line_height + g.Style.ItemSpacing.y));
window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPosPrevLine.x);
window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y);
//window->DrawList->AddCircle(window->DC.CursorMaxPos, 3.0f, 0xFF0000FF, 4); // Debug
window->DC.PrevLineHeight = line_height;
window->DC.PrevLineTextBaseOffset = text_base_offset;
window->DC.CurrentLineHeight = window->DC.CurrentLineTextBaseOffset = 0.0f;
}
void ImGui::ItemSize(const ImRect& bb, float text_offset_y)
{
ItemSize(bb.GetSize(), text_offset_y);
}
// Declare item bounding box for clipping and interaction.
// Note that the size can be different than the one provided to ItemSize(). Typically, widgets that spread over available surface
// declares their minimum size requirement to ItemSize() and then use a larger region for drawing/interaction, which is passed to ItemAdd().
bool ImGui::ItemAdd(const ImRect& bb, const ImGuiID* id)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.LastItemID = id ? *id : 0;
window->DC.LastItemRect = bb;
if (IsClippedEx(bb, id, false))
{
window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
return false;
}
// This is a sensible default, but widgets are free to override it after calling ItemAdd()
ImGuiState& g = *GImGui;
if (IsMouseHoveringRect(bb.Min, bb.Max))
{
// Matching the behavior of IsHovered() but ignore if ActiveId==window->MoveID (we clicked on the window background)
// So that clicking on items with no active id such as Text() still returns true with IsItemHovered()
window->DC.LastItemHoveredRect = true;
window->DC.LastItemHoveredAndUsable = false;
if (g.HoveredRootWindow == window->RootWindow)
if (g.ActiveId == 0 || (id && g.ActiveId == *id) || g.ActiveIdAllowOverlap || (g.ActiveId == window->MoveID))
if (IsWindowContentHoverable(window))
window->DC.LastItemHoveredAndUsable = true;
}
else
{
window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
}
return true;
}
bool ImGui::IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindowRead();
if (!bb.Overlaps(window->ClipRect))
{
if (!id || *id != GImGui->ActiveId)
if (clip_even_when_logged || !g.LogEnabled)
return true;
}
return false;
}
bool ImGui::IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs)
{
ImGuiState& g = *GImGui;
if (g.HoveredId == 0 || g.HoveredId == id || g.HoveredIdAllowOverlap)
{
ImGuiWindow* window = GetCurrentWindowRead();
if (g.HoveredWindow == window || (flatten_childs && g.HoveredRootWindow == window->RootWindow))
if ((g.ActiveId == 0 || g.ActiveId == id || g.ActiveIdAllowOverlap) && ImGui::IsMouseHoveringRect(bb.Min, bb.Max))
if (IsWindowContentHoverable(g.HoveredRootWindow))
return true;
}
return false;
}
bool ImGui::FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop)
{
ImGuiState& g = *GImGui;
const bool allow_keyboard_focus = window->DC.AllowKeyboardFocus;
window->FocusIdxAllCounter++;
if (allow_keyboard_focus)
window->FocusIdxTabCounter++;
// Process keyboard input at this point: TAB, Shift-TAB switch focus
// We can always TAB out of a widget that doesn't allow tabbing in.
if (tab_stop && window->FocusIdxAllRequestNext == IM_INT_MAX && window->FocusIdxTabRequestNext == IM_INT_MAX && is_active && IsKeyPressedMap(ImGuiKey_Tab))
{
// Modulo on index will be applied at the end of frame once we've got the total counter of items.
window->FocusIdxTabRequestNext = window->FocusIdxTabCounter + (g.IO.KeyShift ? (allow_keyboard_focus ? -1 : 0) : +1);
}
if (window->FocusIdxAllCounter == window->FocusIdxAllRequestCurrent)
return true;
if (allow_keyboard_focus)
if (window->FocusIdxTabCounter == window->FocusIdxTabRequestCurrent)
return true;
return false;
}
void ImGui::FocusableItemUnregister(ImGuiWindow* window)
{
window->FocusIdxAllCounter--;
window->FocusIdxTabCounter--;
}
ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_x, float default_y)
{
ImGuiState& g = *GImGui;
ImVec2 content_max;
if (size.x < 0.0f || size.y < 0.0f)
content_max = g.CurrentWindow->Pos + ImGui::GetContentRegionMax();
if (size.x <= 0.0f)
size.x = (size.x == 0.0f) ? default_x : ImMax(content_max.x - g.CurrentWindow->DC.CursorPos.x, 4.0f) + size.x;
if (size.y <= 0.0f)
size.y = (size.y == 0.0f) ? default_y : ImMax(content_max.y - g.CurrentWindow->DC.CursorPos.y, 4.0f) + size.y;
return size;
}
float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
if (wrap_pos_x < 0.0f)
return 0.0f;
ImGuiWindow* window = GetCurrentWindowRead();
if (wrap_pos_x == 0.0f)
wrap_pos_x = ImGui::GetContentRegionMax().x + window->Pos.x;
else if (wrap_pos_x > 0.0f)
wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space
const float wrap_width = wrap_pos_x > 0.0f ? ImMax(wrap_pos_x - pos.x, 0.00001f) : 0.0f;
return wrap_width;
}
//-----------------------------------------------------------------------------
void* ImGui::MemAlloc(size_t sz)
{
GImGui->IO.MetricsAllocs++;
return GImGui->IO.MemAllocFn(sz);
}
void ImGui::MemFree(void* ptr)
{
if (ptr) GImGui->IO.MetricsAllocs--;
return GImGui->IO.MemFreeFn(ptr);
}
const char* ImGui::GetClipboardText()
{
return GImGui->IO.GetClipboardTextFn ? GImGui->IO.GetClipboardTextFn() : "";
}
void ImGui::SetClipboardText(const char* text)
{
if (GImGui->IO.SetClipboardTextFn)
GImGui->IO.SetClipboardTextFn(text);
}
const char* ImGui::GetVersion()
{
return IMGUI_VERSION;
}
// Internal state access - if you want to share ImGui state between modules (e.g. DLL) or allocate it yourself
// Note that we still point to some static data and members (such as GFontAtlas), so the state instance you end up using will point to the static data within its module
void* ImGui::GetInternalState()
{
return GImGui;
}
size_t ImGui::GetInternalStateSize()
{
return sizeof(ImGuiState);
}
void ImGui::SetInternalState(void* state, bool construct)
{
if (construct)
IM_PLACEMENT_NEW(state) ImGuiState();
GImGui = (ImGuiState*)state;
}
ImGuiIO& ImGui::GetIO()
{
return GImGui->IO;
}
ImGuiStyle& ImGui::GetStyle()
{
return GImGui->Style;
}
// Same value as passed to your RenderDrawListsFn() function. valid after Render() and until the next call to NewFrame()
ImDrawData* ImGui::GetDrawData()
{
return GImGui->RenderDrawData.Valid ? &GImGui->RenderDrawData : NULL;
}
float ImGui::GetTime()
{
return GImGui->Time;
}
int ImGui::GetFrameCount()
{
return GImGui->FrameCount;
}
void ImGui::NewFrame()
{
ImGuiState& g = *GImGui;
// Check user data
IM_ASSERT(g.IO.DeltaTime >= 0.0f); // Need a positive DeltaTime (zero is tolerated but will cause some timing issues)
IM_ASSERT(g.IO.DisplaySize.x >= 0.0f && g.IO.DisplaySize.y >= 0.0f);
IM_ASSERT(g.IO.Fonts->Fonts.Size > 0); // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
IM_ASSERT(g.IO.Fonts->Fonts[0]->IsLoaded()); // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
IM_ASSERT(g.Style.CurveTessellationTol > 0.0f); // Invalid style setting
if (!g.Initialized)
{
// Initialize on first frame
g.LogClipboard = (ImGuiTextBuffer*)ImGui::MemAlloc(sizeof(ImGuiTextBuffer));
IM_PLACEMENT_NEW(g.LogClipboard) ImGuiTextBuffer();
IM_ASSERT(g.Settings.empty());
LoadSettings();
g.Initialized = true;
}
SetCurrentFont(g.IO.Fonts->Fonts[0]);
g.Time += g.IO.DeltaTime;
g.FrameCount += 1;
g.Tooltip[0] = '\0';
g.OverlayDrawList.Clear();
g.OverlayDrawList.PushTextureID(g.IO.Fonts->TexID);
g.OverlayDrawList.PushClipRectFullScreen();
g.OverlayDrawList.AddDrawCmd();
// Mark rendering data as invalid to prevent user who may have a handle on it to use it
g.RenderDrawData.Valid = false;
g.RenderDrawData.CmdLists = NULL;
g.RenderDrawData.CmdListsCount = g.RenderDrawData.TotalVtxCount = g.RenderDrawData.TotalIdxCount = 0;
// Update inputs state
if (g.IO.MousePos.x < 0 && g.IO.MousePos.y < 0)
g.IO.MousePos = ImVec2(-9999.0f, -9999.0f);
if ((g.IO.MousePos.x < 0 && g.IO.MousePos.y < 0) || (g.IO.MousePosPrev.x < 0 && g.IO.MousePosPrev.y < 0)) // if mouse just appeared or disappeared (negative coordinate) we cancel out movement in MouseDelta
g.IO.MouseDelta = ImVec2(0.0f, 0.0f);
else
g.IO.MouseDelta = g.IO.MousePos - g.IO.MousePosPrev;
g.IO.MousePosPrev = g.IO.MousePos;
for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
{
g.IO.MouseClicked[i] = g.IO.MouseDown[i] && g.IO.MouseDownDuration[i] < 0.0f;
g.IO.MouseReleased[i] = !g.IO.MouseDown[i] && g.IO.MouseDownDuration[i] >= 0.0f;
g.IO.MouseDownDurationPrev[i] = g.IO.MouseDownDuration[i];
g.IO.MouseDownDuration[i] = g.IO.MouseDown[i] ? (g.IO.MouseDownDuration[i] < 0.0f ? 0.0f : g.IO.MouseDownDuration[i] + g.IO.DeltaTime) : -1.0f;
g.IO.MouseDoubleClicked[i] = false;
if (g.IO.MouseClicked[i])
{
if (g.Time - g.IO.MouseClickedTime[i] < g.IO.MouseDoubleClickTime)
{
if (ImLengthSqr(g.IO.MousePos - g.IO.MouseClickedPos[i]) < g.IO.MouseDoubleClickMaxDist * g.IO.MouseDoubleClickMaxDist)
g.IO.MouseDoubleClicked[i] = true;
g.IO.MouseClickedTime[i] = -FLT_MAX; // so the third click isn't turned into a double-click
}
else
{
g.IO.MouseClickedTime[i] = g.Time;
}
g.IO.MouseClickedPos[i] = g.IO.MousePos;
g.IO.MouseDragMaxDistanceSqr[i] = 0.0f;
}
else if (g.IO.MouseDown[i])
{
g.IO.MouseDragMaxDistanceSqr[i] = ImMax(g.IO.MouseDragMaxDistanceSqr[i], ImLengthSqr(g.IO.MousePos - g.IO.MouseClickedPos[i]));
}
}
memcpy(g.IO.KeysDownDurationPrev, g.IO.KeysDownDuration, sizeof(g.IO.KeysDownDuration));
for (int i = 0; i < IM_ARRAYSIZE(g.IO.KeysDown); i++)
g.IO.KeysDownDuration[i] = g.IO.KeysDown[i] ? (g.IO.KeysDownDuration[i] < 0.0f ? 0.0f : g.IO.KeysDownDuration[i] + g.IO.DeltaTime) : -1.0f;
// Calculate frame-rate for the user, as a purely luxurious feature
g.FramerateSecPerFrameAccum += g.IO.DeltaTime - g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx];
g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx] = g.IO.DeltaTime;
g.FramerateSecPerFrameIdx = (g.FramerateSecPerFrameIdx + 1) % IM_ARRAYSIZE(g.FramerateSecPerFrame);
g.IO.Framerate = 1.0f / (g.FramerateSecPerFrameAccum / (float)IM_ARRAYSIZE(g.FramerateSecPerFrame));
// Clear reference to active widget if the widget isn't alive anymore
g.HoveredIdPreviousFrame = g.HoveredId;
g.HoveredId = 0;
g.HoveredIdAllowOverlap = false;
if (!g.ActiveIdIsAlive && g.ActiveIdPreviousFrame == g.ActiveId && g.ActiveId != 0)
SetActiveID(0);
g.ActiveIdPreviousFrame = g.ActiveId;
g.ActiveIdIsAlive = false;
g.ActiveIdIsJustActivated = false;
if (!g.ActiveId)
g.MovedWindow = NULL;
// Delay saving settings so we don't spam disk too much
if (g.SettingsDirtyTimer > 0.0f)
{
g.SettingsDirtyTimer -= g.IO.DeltaTime;
if (g.SettingsDirtyTimer <= 0.0f)
SaveSettings();
}
// Find the window we are hovering. Child windows can extend beyond the limit of their parent so we need to derive HoveredRootWindow from HoveredWindow
g.HoveredWindow = FindHoveredWindow(g.IO.MousePos, false);
if (g.HoveredWindow && (g.HoveredWindow->Flags & ImGuiWindowFlags_ChildWindow))
g.HoveredRootWindow = g.HoveredWindow->RootWindow;
else
g.HoveredRootWindow = FindHoveredWindow(g.IO.MousePos, true);
if (ImGuiWindow* modal_window = GetFrontMostModalRootWindow())
{
g.ModalWindowDarkeningRatio = ImMin(g.ModalWindowDarkeningRatio + g.IO.DeltaTime * 6.0f, 1.0f);
if (g.HoveredRootWindow != modal_window)
g.HoveredRootWindow = g.HoveredWindow = NULL;
}
else
{
g.ModalWindowDarkeningRatio = 0.0f;
}
// Are we using inputs? Tell user so they can capture/discard the inputs away from the rest of their application.
// When clicking outside of a window we assume the click is owned by the application and won't request capture. We need to track click ownership.
int mouse_earliest_button_down = -1;
bool mouse_any_down = false;
for (int i = 0; i < IM_ARRAYSIZE(g.IO.MouseDown); i++)
{
if (g.IO.MouseClicked[i])
g.IO.MouseDownOwned[i] = (g.HoveredWindow != NULL) || (!g.OpenedPopupStack.empty());
mouse_any_down |= g.IO.MouseDown[i];
if (g.IO.MouseDown[i])
if (mouse_earliest_button_down == -1 || g.IO.MouseClickedTime[mouse_earliest_button_down] > g.IO.MouseClickedTime[i])
mouse_earliest_button_down = i;
}
bool mouse_avail_to_imgui = (mouse_earliest_button_down == -1) || g.IO.MouseDownOwned[mouse_earliest_button_down];
if (g.CaptureMouseNextFrame != -1)
g.IO.WantCaptureMouse = (g.CaptureMouseNextFrame != 0);
else
g.IO.WantCaptureMouse = (mouse_avail_to_imgui && (g.HoveredWindow != NULL || mouse_any_down)) || (g.ActiveId != 0) || (!g.OpenedPopupStack.empty());
g.IO.WantCaptureKeyboard = (g.CaptureKeyboardNextFrame != -1) ? (g.CaptureKeyboardNextFrame != 0) : (g.ActiveId != 0);
g.IO.WantTextInput = (g.ActiveId != 0 && g.InputTextState.Id == g.ActiveId);
g.MouseCursor = ImGuiMouseCursor_Arrow;
g.CaptureMouseNextFrame = g.CaptureKeyboardNextFrame = -1;
g.OsImePosRequest = ImVec2(1.0f, 1.0f); // OS Input Method Editor showing on top-left of our window by default
// If mouse was first clicked outside of ImGui bounds we also cancel out hovering.
if (!mouse_avail_to_imgui)
g.HoveredWindow = g.HoveredRootWindow = NULL;
// Scale & Scrolling
if (g.HoveredWindow && g.IO.MouseWheel != 0.0f && !g.HoveredWindow->Collapsed)
{
ImGuiWindow* window = g.HoveredWindow;
if (g.IO.KeyCtrl)
{
if (g.IO.FontAllowUserScaling)
{
// Zoom / Scale window
float new_font_scale = ImClamp(window->FontWindowScale + g.IO.MouseWheel * 0.10f, 0.50f, 2.50f);
float scale = new_font_scale / window->FontWindowScale;
window->FontWindowScale = new_font_scale;
const ImVec2 offset = window->Size * (1.0f - scale) * (g.IO.MousePos - window->Pos) / window->Size;
window->Pos += offset;
window->PosFloat += offset;
window->Size *= scale;
window->SizeFull *= scale;
}
}
else
{
// Scroll
if (!(window->Flags & ImGuiWindowFlags_NoScrollWithMouse))
{
const int scroll_lines = (window->Flags & ImGuiWindowFlags_ComboBox) ? 3 : 5;
SetWindowScrollY(window, window->Scroll.y - g.IO.MouseWheel * window->CalcFontSize() * scroll_lines);
}
}
}
// Pressing TAB activate widget focus
// NB: Don't discard FocusedWindow if it isn't active, so that a window that go on/off programatically won't lose its keyboard focus.
if (g.ActiveId == 0 && g.FocusedWindow != NULL && g.FocusedWindow->Active && IsKeyPressedMap(ImGuiKey_Tab, false))
g.FocusedWindow->FocusIdxTabRequestNext = 0;
// Mark all windows as not visible
for (int i = 0; i != g.Windows.Size; i++)
{
ImGuiWindow* window = g.Windows[i];
window->WasActive = window->Active;
window->Active = false;
window->Accessed = false;
}
// No window should be open at the beginning of the frame.
// But in order to allow the user to call NewFrame() multiple times without calling Render(), we are doing an explicit clear.
g.CurrentWindowStack.resize(0);
g.CurrentPopupStack.resize(0);
CloseInactivePopups();
// Create implicit window - we will only render it if the user has added something to it.
ImGui::SetNextWindowSize(ImVec2(400,400), ImGuiSetCond_FirstUseEver);
ImGui::Begin("Debug");
}
// NB: behavior of ImGui after Shutdown() is not tested/guaranteed at the moment. This function is merely here to free heap allocations.
void ImGui::Shutdown()
{
ImGuiState& g = *GImGui;
// The fonts atlas can be used prior to calling NewFrame(), so we clear it even if g.Initialized is FALSE (which would happen if we never called NewFrame)
if (g.IO.Fonts) // Testing for NULL to allow user to NULLify in case of running Shutdown() on multiple contexts. Bit hacky.
g.IO.Fonts->Clear();
// Cleanup of other data are conditional on actually having used ImGui.
if (!g.Initialized)
return;
SaveSettings();
for (int i = 0; i < g.Windows.Size; i++)
{
g.Windows[i]->~ImGuiWindow();
ImGui::MemFree(g.Windows[i]);
}
g.Windows.clear();
g.WindowsSortBuffer.clear();
g.CurrentWindowStack.clear();
g.FocusedWindow = NULL;
g.HoveredWindow = NULL;
g.HoveredRootWindow = NULL;
for (int i = 0; i < g.Settings.Size; i++)
ImGui::MemFree(g.Settings[i].Name);
g.Settings.clear();
g.ColorModifiers.clear();
g.StyleModifiers.clear();
g.FontStack.clear();
g.OpenedPopupStack.clear();
g.CurrentPopupStack.clear();
for (int i = 0; i < IM_ARRAYSIZE(g.RenderDrawLists); i++)
g.RenderDrawLists[i].clear();
g.OverlayDrawList.ClearFreeMemory();
g.ColorEditModeStorage.Clear();
if (g.PrivateClipboard)
{
ImGui::MemFree(g.PrivateClipboard);
g.PrivateClipboard = NULL;
}
g.InputTextState.Text.clear();
g.InputTextState.InitialText.clear();
g.InputTextState.TempTextBuffer.clear();
if (g.LogFile && g.LogFile != stdout)
{
fclose(g.LogFile);
g.LogFile = NULL;
}
if (g.LogClipboard)
{
g.LogClipboard->~ImGuiTextBuffer();
ImGui::MemFree(g.LogClipboard);
}
g.Initialized = false;
}
static ImGuiIniData* FindWindowSettings(const char* name)
{
ImGuiState& g = *GImGui;
ImGuiID id = ImHash(name, 0);
for (int i = 0; i != g.Settings.Size; i++)
{
ImGuiIniData* ini = &g.Settings[i];
if (ini->ID == id)
return ini;
}
return NULL;
}
static ImGuiIniData* AddWindowSettings(const char* name)
{
GImGui->Settings.resize(GImGui->Settings.Size + 1);
ImGuiIniData* ini = &GImGui->Settings.back();
ini->Name = ImStrdup(name);
ini->ID = ImHash(name, 0);
ini->Collapsed = false;
ini->Pos = ImVec2(FLT_MAX,FLT_MAX);
ini->Size = ImVec2(0,0);
return ini;
}
// Zero-tolerance, poor-man .ini parsing
// FIXME: Write something less rubbish
static void LoadSettings()
{
ImGuiState& g = *GImGui;
const char* filename = g.IO.IniFilename;
if (!filename)
return;
int file_size;
char* file_data = (char*)ImLoadFileToMemory(filename, "rb", &file_size, 1);
if (!file_data)
return;
ImGuiIniData* settings = NULL;
const char* buf_end = file_data + file_size;
for (const char* line_start = file_data; line_start < buf_end; )
{
const char* line_end = line_start;
while (line_end < buf_end && *line_end != '\n' && *line_end != '\r')
line_end++;
if (line_start[0] == '[' && line_end > line_start && line_end[-1] == ']')
{
char name[64];
ImFormatString(name, IM_ARRAYSIZE(name), "%.*s", (int)(line_end-line_start-2), line_start+1);
settings = FindWindowSettings(name);
if (!settings)
settings = AddWindowSettings(name);
}
else if (settings)
{
float x, y;
int i;
if (sscanf(line_start, "Pos=%f,%f", &x, &y) == 2)
settings->Pos = ImVec2(x, y);
else if (sscanf(line_start, "Size=%f,%f", &x, &y) == 2)
settings->Size = ImMax(ImVec2(x, y), g.Style.WindowMinSize);
else if (sscanf(line_start, "Collapsed=%d", &i) == 1)
settings->Collapsed = (i != 0);
}
line_start = line_end+1;
}
ImGui::MemFree(file_data);
}
static void SaveSettings()
{
ImGuiState& g = *GImGui;
const char* filename = g.IO.IniFilename;
if (!filename)
return;
// Gather data from windows that were active during this session
for (int i = 0; i != g.Windows.Size; i++)
{
ImGuiWindow* window = g.Windows[i];
if (window->Flags & ImGuiWindowFlags_NoSavedSettings)
continue;
ImGuiIniData* settings = FindWindowSettings(window->Name);
settings->Pos = window->Pos;
settings->Size = window->SizeFull;
settings->Collapsed = window->Collapsed;
}
// Write .ini file
// If a window wasn't opened in this session we preserve its settings
FILE* f = fopen(filename, "wt");
if (!f)
return;
for (int i = 0; i != g.Settings.Size; i++)
{
const ImGuiIniData* settings = &g.Settings[i];
if (settings->Pos.x == FLT_MAX)
continue;
const char* name = settings->Name;
if (const char* p = strstr(name, "###")) // Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
name = p;
fprintf(f, "[%s]\n", name);
fprintf(f, "Pos=%d,%d\n", (int)settings->Pos.x, (int)settings->Pos.y);
fprintf(f, "Size=%d,%d\n", (int)settings->Size.x, (int)settings->Size.y);
fprintf(f, "Collapsed=%d\n", settings->Collapsed);
fprintf(f, "\n");
}
fclose(f);
}
static void MarkSettingsDirty()
{
ImGuiState& g = *GImGui;
if (g.SettingsDirtyTimer <= 0.0f)
g.SettingsDirtyTimer = g.IO.IniSavingRate;
}
// FIXME: Add a more explicit sort order in the window structure.
static int ChildWindowComparer(const void* lhs, const void* rhs)
{
const ImGuiWindow* a = *(const ImGuiWindow**)lhs;
const ImGuiWindow* b = *(const ImGuiWindow**)rhs;
if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
return d;
if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip))
return d;
if (int d = (a->Flags & ImGuiWindowFlags_ComboBox) - (b->Flags & ImGuiWindowFlags_ComboBox))
return d;
return 0;
}
static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window)
{
out_sorted_windows.push_back(window);
if (window->Active)
{
int count = window->DC.ChildWindows.Size;
if (count > 1)
qsort(window->DC.ChildWindows.begin(), (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
for (int i = 0; i < count; i++)
{
ImGuiWindow* child = window->DC.ChildWindows[i];
if (child->Active)
AddWindowToSortedBuffer(out_sorted_windows, child);
}
}
}
static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list)
{
if (draw_list->CmdBuffer.empty())
return;
// Remove trailing command if unused
ImDrawCmd& last_cmd = draw_list->CmdBuffer.back();
if (last_cmd.ElemCount == 0 && last_cmd.UserCallback == NULL)
{
draw_list->CmdBuffer.pop_back();
if (draw_list->CmdBuffer.empty())
return;
}
// Check that draw_list doesn't use more vertices than indexable (default ImDrawIdx = 2 bytes = 64K vertices)
// If this assert triggers because you are drawing lots of stuff manually, A) workaround by calling BeginChild()/EndChild() to put your draw commands in multiple draw lists, B) #define ImDrawIdx to a 'unsigned int' in imconfig.h and render accordingly.
IM_ASSERT((int)draw_list->_VtxCurrentIdx == draw_list->VtxBuffer.Size); // Sanity check. Bug or mismatch between PrimReserve() calls and incrementing _VtxCurrentIdx, _VtxWritePtr etc.
IM_ASSERT((int64_t)draw_list->_VtxCurrentIdx <= ((int64_t)1L << (sizeof(ImDrawIdx)*8))); // Too many vertices in same ImDrawList. See comment above.
out_render_list.push_back(draw_list);
GImGui->IO.MetricsRenderVertices += draw_list->VtxBuffer.Size;
GImGui->IO.MetricsRenderIndices += draw_list->IdxBuffer.Size;
}
static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window)
{
AddDrawListToRenderList(out_render_list, window->DrawList);
for (int i = 0; i < window->DC.ChildWindows.Size; i++)
{
ImGuiWindow* child = window->DC.ChildWindows[i];
if (!child->Active) // clipped children may have been marked not active
continue;
if ((child->Flags & ImGuiWindowFlags_Popup) && child->HiddenFrames > 0)
continue;
AddWindowToRenderList(out_render_list, child);
}
}
void ImGui::PushClipRect(const ImVec2& clip_rect_min, const ImVec2& clip_rect_max, bool intersect_with_existing_clip_rect)
{
ImGuiWindow* window = GetCurrentWindow();
ImRect cr(clip_rect_min, clip_rect_max);
if (intersect_with_existing_clip_rect)
{
// Clip our argument with the current clip rect
cr.Clip(window->ClipRect);
}
cr.Max.x = ImMax(cr.Min.x, cr.Max.x);
cr.Max.y = ImMax(cr.Min.y, cr.Max.y);
IM_ASSERT(cr.Min.x <= cr.Max.x && cr.Min.y <= cr.Max.y);
window->ClipRect = cr;
window->DrawList->PushClipRect(ImVec4(cr.Min.x, cr.Min.y, cr.Max.x, cr.Max.y));
}
void ImGui::PopClipRect()
{
ImGuiWindow* window = GetCurrentWindow();
window->DrawList->PopClipRect();
window->ClipRect = window->DrawList->_ClipRectStack.back();
}
// This is normally called by Render(). You may want to call it directly if you want to avoid calling Render() but the gain will be very minimal.
void ImGui::EndFrame()
{
ImGuiState& g = *GImGui;
IM_ASSERT(g.Initialized); // Forgot to call ImGui::NewFrame()
IM_ASSERT(g.FrameCountEnded != g.FrameCount); // ImGui::EndFrame() called multiple times, or forgot to call ImGui::NewFrame() again
// Render tooltip
if (g.Tooltip[0])
{
ImGui::BeginTooltip();
ImGui::TextUnformatted(g.Tooltip);
ImGui::EndTooltip();
}
// Notify OS when our Input Method Editor cursor has moved (e.g. CJK inputs using Microsoft IME)
if (g.IO.ImeSetInputScreenPosFn && ImLengthSqr(g.OsImePosRequest - g.OsImePosSet) > 0.0001f)
{
g.IO.ImeSetInputScreenPosFn((int)g.OsImePosRequest.x, (int)g.OsImePosRequest.y);
g.OsImePosSet = g.OsImePosRequest;
}
// Hide implicit "Debug" window if it hasn't been used
IM_ASSERT(g.CurrentWindowStack.Size == 1); // Mismatched Begin()/End() calls
if (g.CurrentWindow && !g.CurrentWindow->Accessed)
g.CurrentWindow->Active = false;
ImGui::End();
// Click to focus window and start moving (after we're done with all our widgets)
if (!g.ActiveId)
g.MovedWindow = NULL;
if (g.ActiveId == 0 && g.HoveredId == 0 && g.IO.MouseClicked[0])
{
if (!(g.FocusedWindow && !g.FocusedWindow->WasActive && g.FocusedWindow->Active)) // Unless we just made a popup appear
{
if (g.HoveredRootWindow != NULL)
{
FocusWindow(g.HoveredWindow);
if (!(g.HoveredWindow->Flags & ImGuiWindowFlags_NoMove))
{
g.MovedWindow = g.HoveredWindow;
SetActiveID(g.HoveredRootWindow->MoveID, g.HoveredRootWindow);
}
}
else if (g.FocusedWindow != NULL && GetFrontMostModalRootWindow() == NULL)
{
// Clicking on void disable focus
FocusWindow(NULL);
}
}
}
// Sort the window list so that all child windows are after their parent
// We cannot do that on FocusWindow() because childs may not exist yet
g.WindowsSortBuffer.resize(0);
g.WindowsSortBuffer.reserve(g.Windows.Size);
for (int i = 0; i != g.Windows.Size; i++)
{
ImGuiWindow* window = g.Windows[i];
if (window->Active && (window->Flags & ImGuiWindowFlags_ChildWindow)) // if a child is active its parent will add it
continue;
AddWindowToSortedBuffer(g.WindowsSortBuffer, window);
}
IM_ASSERT(g.Windows.Size == g.WindowsSortBuffer.Size); // we done something wrong
g.Windows.swap(g.WindowsSortBuffer);
// Clear Input data for next frame
g.IO.MouseWheel = 0.0f;
memset(g.IO.InputCharacters, 0, sizeof(g.IO.InputCharacters));
g.FrameCountEnded = g.FrameCount;
}
void ImGui::Render()
{
ImGuiState& g = *GImGui;
IM_ASSERT(g.Initialized); // Forgot to call ImGui::NewFrame()
if (g.FrameCountEnded != g.FrameCount)
ImGui::EndFrame();
g.FrameCountRendered = g.FrameCount;
// Skip render altogether if alpha is 0.0
// Note that vertex buffers have been created and are wasted, so it is best practice that you don't create windows in the first place, or consistently respond to Begin() returning false.
if (g.Style.Alpha > 0.0f)
{
// Gather windows to render
g.IO.MetricsRenderVertices = g.IO.MetricsRenderIndices = g.IO.MetricsActiveWindows = 0;
for (int i = 0; i < IM_ARRAYSIZE(g.RenderDrawLists); i++)
g.RenderDrawLists[i].resize(0);
for (int i = 0; i != g.Windows.Size; i++)
{
ImGuiWindow* window = g.Windows[i];
if (window->Active && window->HiddenFrames <= 0 && (window->Flags & (ImGuiWindowFlags_ChildWindow)) == 0)
{
// FIXME: Generalize this with a proper layering system so e.g. user can draw in specific layers, below text, ..
g.IO.MetricsActiveWindows++;
if (window->Flags & ImGuiWindowFlags_Popup)
AddWindowToRenderList(g.RenderDrawLists[1], window);
else if (window->Flags & ImGuiWindowFlags_Tooltip)
AddWindowToRenderList(g.RenderDrawLists[2], window);
else
AddWindowToRenderList(g.RenderDrawLists[0], window);
}
}
// Flatten layers
int n = g.RenderDrawLists[0].Size;
int flattened_size = n;
for (int i = 1; i < IM_ARRAYSIZE(g.RenderDrawLists); i++)
flattened_size += g.RenderDrawLists[i].Size;
g.RenderDrawLists[0].resize(flattened_size);
for (int i = 1; i < IM_ARRAYSIZE(g.RenderDrawLists); i++)
{
ImVector<ImDrawList*>& layer = g.RenderDrawLists[i];
if (layer.empty())
continue;
memcpy(&g.RenderDrawLists[0][n], &layer[0], layer.Size * sizeof(ImDrawList*));
n += layer.Size;
}
// Draw software mouse cursor if requested
if (g.IO.MouseDrawCursor)
{
const ImGuiMouseCursorData& cursor_data = g.MouseCursorData[g.MouseCursor];
const ImVec2 pos = g.IO.MousePos - cursor_data.HotOffset;
const ImVec2 size = cursor_data.Size;
const ImTextureID tex_id = g.IO.Fonts->TexID;
g.OverlayDrawList.PushTextureID(tex_id);
g.OverlayDrawList.AddImage(tex_id, pos+ImVec2(1,0), pos+ImVec2(1,0) + size, cursor_data.TexUvMin[1], cursor_data.TexUvMax[1], 0x30000000); // Shadow
g.OverlayDrawList.AddImage(tex_id, pos+ImVec2(2,0), pos+ImVec2(2,0) + size, cursor_data.TexUvMin[1], cursor_data.TexUvMax[1], 0x30000000); // Shadow
g.OverlayDrawList.AddImage(tex_id, pos, pos + size, cursor_data.TexUvMin[1], cursor_data.TexUvMax[1], 0xFF000000); // Black border
g.OverlayDrawList.AddImage(tex_id, pos, pos + size, cursor_data.TexUvMin[0], cursor_data.TexUvMax[0], 0xFFFFFFFF); // White fill
g.OverlayDrawList.PopTextureID();
}
if (!g.OverlayDrawList.VtxBuffer.empty())
AddDrawListToRenderList(g.RenderDrawLists[0], &g.OverlayDrawList);
// Setup draw data
g.RenderDrawData.Valid = true;
g.RenderDrawData.CmdLists = (g.RenderDrawLists[0].Size > 0) ? &g.RenderDrawLists[0][0] : NULL;
g.RenderDrawData.CmdListsCount = g.RenderDrawLists[0].Size;
g.RenderDrawData.TotalVtxCount = g.IO.MetricsRenderVertices;
g.RenderDrawData.TotalIdxCount = g.IO.MetricsRenderIndices;
// Render. If user hasn't set a callback then they may retrieve the draw data via GetDrawData()
if (g.RenderDrawData.CmdListsCount > 0 && g.IO.RenderDrawListsFn != NULL)
g.IO.RenderDrawListsFn(&g.RenderDrawData);
}
}
const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
const char* text_display_end = text;
if (!text_end)
text_end = (const char*)-1;
while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
text_display_end++;
return text_display_end;
}
// Pass text data straight to log (without being displayed)
void ImGui::LogText(const char* fmt, ...)
{
ImGuiState& g = *GImGui;
if (!g.LogEnabled)
return;
va_list args;
va_start(args, fmt);
if (g.LogFile)
{
vfprintf(g.LogFile, fmt, args);
}
else
{
g.LogClipboard->appendv(fmt, args);
}
va_end(args);
}
// Internal version that takes a position to decide on newline placement and pad items according to their depth.
// We split text into individual lines to add current tree level padding
static void LogRenderedText(const ImVec2& ref_pos, const char* text, const char* text_end)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = ImGui::GetCurrentWindowRead();
if (!text_end)
text_end = ImGui::FindRenderedTextEnd(text, text_end);
const bool log_new_line = ref_pos.y > window->DC.LogLinePosY+1;
window->DC.LogLinePosY = ref_pos.y;
const char* text_remaining = text;
if (g.LogStartDepth > window->DC.TreeDepth) // Re-adjust padding if we have popped out of our starting depth
g.LogStartDepth = window->DC.TreeDepth;
const int tree_depth = (window->DC.TreeDepth - g.LogStartDepth);
for (;;)
{
// Split the string. Each new line (after a '\n') is followed by spacing corresponding to the current depth of our log entry.
const char* line_end = text_remaining;
while (line_end < text_end)
if (*line_end == '\n')
break;
else
line_end++;
if (line_end >= text_end)
line_end = NULL;
const bool is_first_line = (text == text_remaining);
bool is_last_line = false;
if (line_end == NULL)
{
is_last_line = true;
line_end = text_end;
}
if (line_end != NULL && !(is_last_line && (line_end - text_remaining)==0))
{
const int char_count = (int)(line_end - text_remaining);
if (log_new_line || !is_first_line)
ImGui::LogText(IM_NEWLINE "%*s%.*s", tree_depth*4, "", char_count, text_remaining);
else
ImGui::LogText(" %.*s", char_count, text_remaining);
}
if (is_last_line)
break;
text_remaining = line_end + 1;
}
}
// Internal ImGui functions to render text
// RenderText***() functions calls ImDrawList::AddText() calls ImBitmapFont::RenderText()
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
// Hide anything after a '##' string
const char* text_display_end;
if (hide_text_after_hash)
{
text_display_end = FindRenderedTextEnd(text, text_end);
}
else
{
if (!text_end)
text_end = text + strlen(text); // FIXME-OPT
text_display_end = text_end;
}
const int text_len = (int)(text_display_end - text);
if (text_len > 0)
{
window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
if (g.LogEnabled)
LogRenderedText(pos, text, text_display_end);
}
}
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
if (!text_end)
text_end = text + strlen(text); // FIXME-OPT
const int text_len = (int)(text_end - text);
if (text_len > 0)
{
window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_end, wrap_width);
if (g.LogEnabled)
LogRenderedText(pos, text, text_end);
}
}
// Handle clipping on CPU immediately (vs typically let the GPU clip the triangles that are overlapping the clipping rectangle edges)
void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImGuiAlign align, const ImVec2* clip_min, const ImVec2* clip_max)
{
// Hide anything after a '##' string
const char* text_display_end = FindRenderedTextEnd(text, text_end);
const int text_len = (int)(text_display_end - text);
if (text_len == 0)
return;
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
// Perform CPU side clipping for single clipped element to avoid using scissor state
ImVec2 pos = pos_min;
const ImVec2 text_size = text_size_if_known ? *text_size_if_known : ImGui::CalcTextSize(text, text_display_end, false, 0.0f);
if (!clip_max) clip_max = &pos_max;
bool need_clipping = (pos.x + text_size.x >= clip_max->x) || (pos.y + text_size.y >= clip_max->y);
if (!clip_min) clip_min = &pos_min; else need_clipping |= (pos.x < clip_min->x) || (pos.y < clip_min->y);
// Align
if (align & ImGuiAlign_Center) pos.x = ImMax(pos.x, (pos.x + pos_max.x - text_size.x) * 0.5f);
else if (align & ImGuiAlign_Right) pos.x = ImMax(pos.x, pos_max.x - text_size.x);
if (align & ImGuiAlign_VCenter) pos.y = ImMax(pos.y, (pos.y + pos_max.y - text_size.y) * 0.5f);
// Render
if (need_clipping)
{
ImVec4 fine_clip_rect(clip_min->x, clip_min->y, clip_max->x, clip_max->y);
window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, &fine_clip_rect);
}
else
{
window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, NULL);
}
if (g.LogEnabled)
LogRenderedText(pos, text, text_display_end);
}
// Render a rectangle shaped with optional rounding and borders
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
ImGuiWindow* window = GetCurrentWindow();
window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
if (border && (window->Flags & ImGuiWindowFlags_ShowBorders))
{
window->DrawList->AddRect(p_min+ImVec2(1,1), p_max+ImVec2(1,1), GetColorU32(ImGuiCol_BorderShadow), rounding);
window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding);
}
}
// Render a triangle to denote expanded/collapsed state
void ImGui::RenderCollapseTriangle(ImVec2 p_min, bool opened, float scale, bool shadow)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
const float h = g.FontSize * 1.00f;
const float r = h * 0.40f * scale;
ImVec2 center = p_min + ImVec2(h*0.50f, h*0.50f*scale);
ImVec2 a, b, c;
if (opened)
{
center.y -= r*0.25f;
a = center + ImVec2(0,1)*r;
b = center + ImVec2(-0.866f,-0.5f)*r;
c = center + ImVec2(0.866f,-0.5f)*r;
}
else
{
a = center + ImVec2(1,0)*r;
b = center + ImVec2(-0.500f,0.866f)*r;
c = center + ImVec2(-0.500f,-0.866f)*r;
}
if (shadow && (window->Flags & ImGuiWindowFlags_ShowBorders) != 0)
window->DrawList->AddTriangleFilled(a+ImVec2(2,2), b+ImVec2(2,2), c+ImVec2(2,2), GetColorU32(ImGuiCol_BorderShadow));
window->DrawList->AddTriangleFilled(a, b, c, GetColorU32(ImGuiCol_Text));
}
void ImGui::RenderCheckMark(ImVec2 pos, ImU32 col)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
ImVec2 a, b, c;
float start_x = (float)(int)(g.FontSize * 0.307f + 0.5f);
float rem_third = (float)(int)((g.FontSize - start_x) / 3.0f);
a.x = pos.x + 0.5f + start_x;
b.x = a.x + rem_third;
c.x = a.x + rem_third * 3.0f;
b.y = pos.y - 1.0f + (float)(int)(g.Font->Ascent * (g.FontSize / g.Font->FontSize) + 0.5f) + (float)(int)(g.Font->DisplayOffset.y);
a.y = b.y - rem_third;
c.y = b.y - rem_third * 2.0f;
window->DrawList->PathLineTo(a);
window->DrawList->PathLineTo(b);
window->DrawList->PathLineTo(c);
window->DrawList->PathStroke(col, false);
}
// Calculate text size. Text can be multi-line. Optionally ignore text after a ## marker.
// CalcTextSize("") should return ImVec2(0.0f, GImGui->FontSize)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
ImGuiState& g = *GImGui;
const char* text_display_end;
if (hide_text_after_double_hash)
text_display_end = FindRenderedTextEnd(text, text_end); // Hide anything after a '##' string
else
text_display_end = text_end;
ImFont* font = g.Font;
const float font_size = g.FontSize;
if (text == text_display_end)
return ImVec2(0.0f, font_size);
ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);
// Cancel out character spacing for the last character of a line (it is baked into glyph->XAdvance field)
const float font_scale = font_size / font->FontSize;
const float character_spacing_x = 1.0f * font_scale;
if (text_size.x > 0.0f)
text_size.x -= character_spacing_x;
text_size.x = (float)(int)(text_size.x + 0.95f);
return text_size;
}
// Helper to calculate coarse clipping of large list of evenly sized items.
// NB: Prefer using the ImGuiListClipper higher-level helper if you can!
// NB: 'items_count' is only used to clamp the result, if you don't know your count you can use INT_MAX
// If you are displaying thousands of items and you have a random access to the list, you can perform clipping yourself to save on CPU.
// {
// float item_height = ImGui::GetTextLineHeightWithSpacing();
// int display_start, display_end;
// ImGui::CalcListClipping(count, item_height, &display_start, &display_end); // calculate how many to clip/display
// ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (display_start) * item_height); // advance cursor
// for (int i = display_start; i < display_end; i++) // display only visible items
// // TODO: display visible item
// ImGui::SetCursorPosY(ImGui::GetCursorPosY() + (count - display_end) * item_height); // advance cursor
// }
void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindowRead();
if (g.LogEnabled)
{
// If logging is active, do not perform any clipping
*out_items_display_start = 0;
*out_items_display_end = items_count;
return;
}
const ImVec2 pos = window->DC.CursorPos;
int start = (int)((window->ClipRect.Min.y - pos.y) / items_height);
int end = (int)((window->ClipRect.Max.y - pos.y) / items_height);
start = ImClamp(start, 0, items_count);
end = ImClamp(end + 1, start, items_count);
*out_items_display_start = start;
*out_items_display_end = end;
}
// Find window given position, search front-to-back
static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs)
{
ImGuiState& g = *GImGui;
for (int i = g.Windows.Size-1; i >= 0; i--)
{
ImGuiWindow* window = g.Windows[i];
if (!window->Active)
continue;
if (window->Flags & ImGuiWindowFlags_NoInputs)
continue;
if (excluding_childs && (window->Flags & ImGuiWindowFlags_ChildWindow) != 0)
continue;
// Using the clipped AABB so a child window will typically be clipped by its parent.
ImRect bb(window->ClippedWindowRect.Min - g.Style.TouchExtraPadding, window->ClippedWindowRect.Max + g.Style.TouchExtraPadding);
if (bb.Contains(pos))
return window;
}
return NULL;
}
// Test if mouse cursor is hovering given rectangle
// NB- Rectangle is clipped by our current clip setting
// NB- Expand the rectangle to be generous on imprecise inputs systems (g.Style.TouchExtraPadding)
bool ImGui::IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindowRead();
// Clip
ImRect rect_clipped(r_min, r_max);
if (clip)
rect_clipped.Clip(window->ClipRect);
// Expand for touch input
const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
return rect_for_touch.Contains(g.IO.MousePos);
}
bool ImGui::IsMouseHoveringWindow()
{
ImGuiState& g = *GImGui;
return g.HoveredWindow == g.CurrentWindow;
}
bool ImGui::IsMouseHoveringAnyWindow()
{
ImGuiState& g = *GImGui;
return g.HoveredWindow != NULL;
}
bool ImGui::IsPosHoveringAnyWindow(const ImVec2& pos)
{
return FindHoveredWindow(pos, false) != NULL;
}
static bool IsKeyPressedMap(ImGuiKey key, bool repeat)
{
const int key_index = GImGui->IO.KeyMap[key];
return ImGui::IsKeyPressed(key_index, repeat);
}
int ImGui::GetKeyIndex(ImGuiKey key)
{
IM_ASSERT(key >= 0 && key < ImGuiKey_COUNT);
return GImGui->IO.KeyMap[key];
}
bool ImGui::IsKeyDown(int key_index)
{
if (key_index < 0) return false;
IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(GImGui->IO.KeysDown));
return GImGui->IO.KeysDown[key_index];
}
bool ImGui::IsKeyPressed(int key_index, bool repeat)
{
ImGuiState& g = *GImGui;
if (key_index < 0) return false;
IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
const float t = g.IO.KeysDownDuration[key_index];
if (t == 0.0f)
return true;
if (repeat && t > g.IO.KeyRepeatDelay)
{
float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
return true;
}
return false;
}
bool ImGui::IsKeyReleased(int key_index)
{
ImGuiState& g = *GImGui;
if (key_index < 0) return false;
IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
if (g.IO.KeysDownDurationPrev[key_index] >= 0.0f && !g.IO.KeysDown[key_index])
return true;
return false;
}
bool ImGui::IsMouseDown(int button)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
return g.IO.MouseDown[button];
}
bool ImGui::IsMouseClicked(int button, bool repeat)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
const float t = g.IO.MouseDownDuration[button];
if (t == 0.0f)
return true;
if (repeat && t > g.IO.KeyRepeatDelay)
{
float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
return true;
}
return false;
}
bool ImGui::IsMouseReleased(int button)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
return g.IO.MouseReleased[button];
}
bool ImGui::IsMouseDoubleClicked(int button)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
return g.IO.MouseDoubleClicked[button];
}
bool ImGui::IsMouseDragging(int button, float lock_threshold)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
if (!g.IO.MouseDown[button])
return false;
if (lock_threshold < 0.0f)
lock_threshold = g.IO.MouseDragThreshold;
return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}
ImVec2 ImGui::GetMousePos()
{
return GImGui->IO.MousePos;
}
// NB: prefer to call right after BeginPopup(). At the time Selectable/MenuItem is activated, the popup is already closed!
ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
{
ImGuiState& g = *GImGui;
if (g.CurrentPopupStack.Size > 0)
return g.OpenedPopupStack[g.CurrentPopupStack.Size-1].MousePosOnOpen;
return g.IO.MousePos;
}
ImVec2 ImGui::GetMouseDragDelta(int button, float lock_threshold)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
if (lock_threshold < 0.0f)
lock_threshold = g.IO.MouseDragThreshold;
if (g.IO.MouseDown[button])
if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
return g.IO.MousePos - g.IO.MouseClickedPos[button]; // Assume we can only get active with left-mouse button (at the moment).
return ImVec2(0.0f, 0.0f);
}
void ImGui::ResetMouseDragDelta(int button)
{
ImGuiState& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
// NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
g.IO.MouseClickedPos[button] = g.IO.MousePos;
}
ImGuiMouseCursor ImGui::GetMouseCursor()
{
return GImGui->MouseCursor;
}
void ImGui::SetMouseCursor(ImGuiMouseCursor cursor_type)
{
GImGui->MouseCursor = cursor_type;
}
void ImGui::CaptureKeyboardFromApp(bool capture)
{
GImGui->CaptureKeyboardNextFrame = capture ? 1 : 0;
}
void ImGui::CaptureMouseFromApp(bool capture)
{
GImGui->CaptureMouseNextFrame = capture ? 1 : 0;
}
bool ImGui::IsItemHovered()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.LastItemHoveredAndUsable;
}
bool ImGui::IsItemHoveredRect()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.LastItemHoveredRect;
}
bool ImGui::IsItemActive()
{
ImGuiState& g = *GImGui;
if (g.ActiveId)
{
ImGuiWindow* window = GetCurrentWindowRead();
return g.ActiveId == window->DC.LastItemID;
}
return false;
}
bool ImGui::IsAnyItemHovered()
{
return GImGui->HoveredId != 0 || GImGui->HoveredIdPreviousFrame != 0;
}
bool ImGui::IsAnyItemActive()
{
return GImGui->ActiveId != 0;
}
bool ImGui::IsItemVisible()
{
ImGuiWindow* window = GetCurrentWindowRead();
ImRect r(window->ClipRect);
return r.Overlaps(window->DC.LastItemRect);
}
// Allow last item to be overlapped by a subsequent item. Both may be activated during the same frame before the later one takes priority.
void ImGui::SetItemAllowOverlap()
{
ImGuiState& g = *GImGui;
if (g.HoveredId == g.CurrentWindow->DC.LastItemID)
g.HoveredIdAllowOverlap = true;
if (g.ActiveId == g.CurrentWindow->DC.LastItemID)
g.ActiveIdAllowOverlap = true;
}
ImVec2 ImGui::GetItemRectMin()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.LastItemRect.Min;
}
ImVec2 ImGui::GetItemRectMax()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.LastItemRect.Max;
}
ImVec2 ImGui::GetItemRectSize()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.LastItemRect.GetSize();
}
ImVec2 ImGui::CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge, float outward)
{
ImGuiWindow* window = GetCurrentWindowRead();
ImRect rect = window->DC.LastItemRect;
rect.Expand(outward);
return rect.GetClosestPoint(pos, on_edge);
}
// Tooltip is stored and turned into a BeginTooltip()/EndTooltip() sequence at the end of the frame. Each call override previous value.
void ImGui::SetTooltipV(const char* fmt, va_list args)
{
ImGuiState& g = *GImGui;
ImFormatStringV(g.Tooltip, IM_ARRAYSIZE(g.Tooltip), fmt, args);
}
void ImGui::SetTooltip(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
SetTooltipV(fmt, args);
va_end(args);
}
static ImRect GetVisibleRect()
{
ImGuiState& g = *GImGui;
if (g.IO.DisplayVisibleMin.x != g.IO.DisplayVisibleMax.x && g.IO.DisplayVisibleMin.y != g.IO.DisplayVisibleMax.y)
return ImRect(g.IO.DisplayVisibleMin, g.IO.DisplayVisibleMax);
return ImRect(0.0f, 0.0f, g.IO.DisplaySize.x, g.IO.DisplaySize.y);
}
void ImGui::BeginTooltip()
{
ImGuiWindowFlags flags = ImGuiWindowFlags_Tooltip|ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize;
ImGui::Begin("##Tooltip", NULL, flags);
}
void ImGui::EndTooltip()
{
IM_ASSERT(GetCurrentWindowRead()->Flags & ImGuiWindowFlags_Tooltip); // Mismatched BeginTooltip()/EndTooltip() calls
ImGui::End();
}
static bool IsPopupOpen(ImGuiID id)
{
ImGuiState& g = *GImGui;
const bool opened = g.OpenedPopupStack.Size > g.CurrentPopupStack.Size && g.OpenedPopupStack[g.CurrentPopupStack.Size].PopupID == id;
return opened;
}
// Mark popup as open (toggle toward open state).
// Popups are closed when user click outside, or activate a pressable item, or CloseCurrentPopup() is called within a BeginPopup()/EndPopup() block.
// Popup identifiers are relative to the current ID-stack (so OpenPopup and BeginPopup needs to be at the same level).
// One open popup per level of the popup hierarchy (NB: when assigning we reset the Window member of ImGuiPopupRef to NULL)
void ImGui::OpenPopupEx(const char* str_id, bool reopen_existing)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiID id = window->GetID(str_id);
int current_stack_size = g.CurrentPopupStack.Size;
ImGuiPopupRef popup_ref = ImGuiPopupRef(id, window, window->GetID("##menus"), g.IO.MousePos); // Tagged as new ref because constructor sets Window to NULL (we are passing the ParentWindow info here)
if (g.OpenedPopupStack.Size < current_stack_size + 1)
g.OpenedPopupStack.push_back(popup_ref);
else if (reopen_existing || g.OpenedPopupStack[current_stack_size].PopupID != id)
{
g.OpenedPopupStack.resize(current_stack_size+1);
g.OpenedPopupStack[current_stack_size] = popup_ref;
}
}
void ImGui::OpenPopup(const char* str_id)
{
ImGui::OpenPopupEx(str_id, false);
}
static void CloseInactivePopups()
{
ImGuiState& g = *GImGui;
if (g.OpenedPopupStack.empty())
return;
// When popups are stacked, clicking on a lower level popups puts focus back to it and close popups above it.
// Don't close our own child popup windows
int n = 0;
if (g.FocusedWindow)
{
for (n = 0; n < g.OpenedPopupStack.Size; n++)
{
ImGuiPopupRef& popup = g.OpenedPopupStack[n];
if (!popup.Window)
continue;
IM_ASSERT((popup.Window->Flags & ImGuiWindowFlags_Popup) != 0);
if (popup.Window->Flags & ImGuiWindowFlags_ChildWindow)
continue;
bool has_focus = false;
for (int m = n; m < g.OpenedPopupStack.Size && !has_focus; m++)
has_focus = (g.OpenedPopupStack[m].Window && g.OpenedPopupStack[m].Window->RootWindow == g.FocusedWindow->RootWindow);
if (!has_focus)
break;
}
}
if (n < g.OpenedPopupStack.Size) // This test is not required but it allows to set a useful breakpoint on the line below
g.OpenedPopupStack.resize(n);
}
static ImGuiWindow* GetFrontMostModalRootWindow()
{
ImGuiState& g = *GImGui;
if (!g.OpenedPopupStack.empty())
if (ImGuiWindow* front_most_popup = g.OpenedPopupStack.back().Window)
if (front_most_popup->Flags & ImGuiWindowFlags_Modal)
return front_most_popup;
return NULL;
}
static void ClosePopupToLevel(int remaining)
{
ImGuiState& g = *GImGui;
if (remaining > 0)
ImGui::FocusWindow(g.OpenedPopupStack[remaining-1].Window);
else
ImGui::FocusWindow(g.OpenedPopupStack[0].ParentWindow);
g.OpenedPopupStack.resize(remaining);
}
static void ClosePopup(ImGuiID id)
{
if (!IsPopupOpen(id))
return;
ImGuiState& g = *GImGui;
ClosePopupToLevel(g.OpenedPopupStack.Size - 1);
}
// Close the popup we have begin-ed into.
void ImGui::CloseCurrentPopup()
{
ImGuiState& g = *GImGui;
int popup_idx = g.CurrentPopupStack.Size - 1;
if (popup_idx < 0 || popup_idx > g.OpenedPopupStack.Size || g.CurrentPopupStack[popup_idx].PopupID != g.OpenedPopupStack[popup_idx].PopupID)
return;
while (popup_idx > 0 && g.OpenedPopupStack[popup_idx].Window && (g.OpenedPopupStack[popup_idx].Window->Flags & ImGuiWindowFlags_ChildMenu))
popup_idx--;
ClosePopupToLevel(popup_idx);
}
static inline void ClearSetNextWindowData()
{
ImGuiState& g = *GImGui;
g.SetNextWindowPosCond = g.SetNextWindowSizeCond = g.SetNextWindowContentSizeCond = g.SetNextWindowCollapsedCond = 0;
g.SetNextWindowFocus = false;
}
static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
const ImGuiID id = window->GetID(str_id);
if (!IsPopupOpen(id))
{
ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
return false;
}
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize;
char name[32];
if (flags & ImGuiWindowFlags_ChildMenu)
ImFormatString(name, 20, "##menu_%d", g.CurrentPopupStack.Size); // Recycle windows based on depth
else
ImFormatString(name, 20, "##popup_%08x", id); // Not recycling, so we can close/open during the same frame
bool opened = ImGui::Begin(name, NULL, flags);
if (!(window->Flags & ImGuiWindowFlags_ShowBorders))
g.CurrentWindow->Flags &= ~ImGuiWindowFlags_ShowBorders;
if (!opened) // opened can be 'false' when the popup is completely clipped (e.g. zero size display)
ImGui::EndPopup();
return opened;
}
bool ImGui::BeginPopup(const char* str_id)
{
if (GImGui->OpenedPopupStack.Size <= GImGui->CurrentPopupStack.Size) // Early out for performance
{
ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
return false;
}
return BeginPopupEx(str_id, ImGuiWindowFlags_ShowBorders);
}
bool ImGui::BeginPopupModal(const char* name, bool* p_opened, ImGuiWindowFlags extra_flags)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
const ImGuiID id = window->GetID(name);
if (!IsPopupOpen(id))
{
ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
return false;
}
ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_Modal|ImGuiWindowFlags_NoCollapse|ImGuiWindowFlags_NoSavedSettings;
bool opened = ImGui::Begin(name, p_opened, flags);
if (!opened || (p_opened && !*p_opened)) // Opened can be 'false' when the popup is completely clipped (e.g. zero size display)
{
ImGui::EndPopup();
if (opened)
ClosePopup(id);
return false;
}
return opened;
}
void ImGui::EndPopup()
{
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup); // Mismatched BeginPopup()/EndPopup() calls
IM_ASSERT(GImGui->CurrentPopupStack.Size > 0);
ImGui::End();
if (!(window->Flags & ImGuiWindowFlags_Modal))
ImGui::PopStyleVar();
}
// This is a helper to handle the most simple case of associating one named popup to one given widget.
// 1. If you have many possible popups (for different "instances" of a same widget, or for wholly different widgets), you may be better off handling
// this yourself so you can store data relative to the widget that opened the popup instead of choosing different popup identifiers.
// 2. If you want right-clicking on the same item to reopen the popup at new location, use the same code replacing IsItemHovered() with IsItemHoveredRect()
// and passing true to the OpenPopupEx().
// Because: hovering an item in a window below the popup won't normally trigger is hovering behavior/coloring. The pattern of ignoring the fact that
// the item isn't interactable (because it is blocked by the active popup) may useful in some situation when e.g. large canvas as one item, content of menu
// driven by click position.
bool ImGui::BeginPopupContextItem(const char* str_id, int mouse_button)
{
if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(mouse_button))
ImGui::OpenPopupEx(str_id, false);
return ImGui::BeginPopup(str_id);
}
bool ImGui::BeginPopupContextWindow(bool also_over_items, const char* str_id, int mouse_button)
{
if (!str_id) str_id = "window_context_menu";
if (ImGui::IsMouseHoveringWindow() && ImGui::IsMouseClicked(mouse_button))
if (also_over_items || !ImGui::IsAnyItemHovered())
ImGui::OpenPopupEx(str_id, true);
return ImGui::BeginPopup(str_id);
}
bool ImGui::BeginPopupContextVoid(const char* str_id, int mouse_button)
{
if (!str_id) str_id = "void_context_menu";
if (!ImGui::IsMouseHoveringAnyWindow() && ImGui::IsMouseClicked(mouse_button))
ImGui::OpenPopupEx(str_id, true);
return ImGui::BeginPopup(str_id);
}
bool ImGui::BeginChild(const char* str_id, const ImVec2& size_arg, bool border, ImGuiWindowFlags extra_flags)
{
ImGuiWindow* window = GetCurrentWindow();
ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_ChildWindow;
const ImVec2 content_avail = ImGui::GetContentRegionAvail();
ImVec2 size = ImRound(size_arg);
if (size.x <= 0.0f)
{
if (size.x == 0.0f)
flags |= ImGuiWindowFlags_ChildWindowAutoFitX;
size.x = ImMax(content_avail.x, 4.0f) - fabsf(size.x); // Arbitrary minimum zero-ish child size of 4.0f (0.0f causing too much issues)
}
if (size.y <= 0.0f)
{
if (size.y == 0.0f)
flags |= ImGuiWindowFlags_ChildWindowAutoFitY;
size.y = ImMax(content_avail.y, 4.0f) - fabsf(size.y);
}
if (border)
flags |= ImGuiWindowFlags_ShowBorders;
flags |= extra_flags;
char title[256];
ImFormatString(title, IM_ARRAYSIZE(title), "%s.%s", window->Name, str_id);
bool ret = ImGui::Begin(title, NULL, size, -1.0f, flags);
if (!(window->Flags & ImGuiWindowFlags_ShowBorders))
GetCurrentWindow()->Flags &= ~ImGuiWindowFlags_ShowBorders;
return ret;
}
bool ImGui::BeginChild(ImGuiID id, const ImVec2& size, bool border, ImGuiWindowFlags extra_flags)
{
char str_id[32];
ImFormatString(str_id, IM_ARRAYSIZE(str_id), "child_%08x", id);
bool ret = ImGui::BeginChild(str_id, size, border, extra_flags);
return ret;
}
void ImGui::EndChild()
{
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow); // Mismatched BeginChild()/EndChild() callss
if ((window->Flags & ImGuiWindowFlags_ComboBox) || window->BeginCount > 1)
{
ImGui::End();
}
else
{
// When using auto-filling child window, we don't provide full width/height to ItemSize so that it doesn't feed back into automatic size-fitting.
ImVec2 sz = ImGui::GetWindowSize();
if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitX) // Arbitrary minimum zero-ish child size of 4.0f causes less trouble than a 0.0f
sz.x = ImMax(4.0f, sz.x);
if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitY)
sz.y = ImMax(4.0f, sz.y);
ImGui::End();
window = GetCurrentWindow();
ImRect bb(window->DC.CursorPos, window->DC.CursorPos + sz);
ItemSize(sz);
ItemAdd(bb, NULL);
}
}
// Helper to create a child window / scrolling region that looks like a normal widget frame.
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
{
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, style.Colors[ImGuiCol_FrameBg]);
ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, style.FrameRounding);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
return ImGui::BeginChild(id, size, (g.CurrentWindow->Flags & ImGuiWindowFlags_ShowBorders) ? true : false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
}
void ImGui::EndChildFrame()
{
ImGui::EndChild();
ImGui::PopStyleVar(2);
ImGui::PopStyleColor();
}
// Save and compare stack sizes on Begin()/End() to detect usage errors
static void CheckStacksSize(ImGuiWindow* window, bool write)
{
// NOT checking: DC.ItemWidth, DC.AllowKeyboardFocus, DC.ButtonRepeat, DC.TextWrapPos (per window) to allow user to conveniently push once and not pop (they are cleared on Begin)
ImGuiState& g = *GImGui;
int* p_backup = &window->DC.StackSizesBackup[0];
{ int current = window->IDStack.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot PopID()
{ int current = window->DC.GroupStack.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot EndGroup()
{ int current = g.CurrentPopupStack.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot EndPopup()/EndMenu()
{ int current = g.ColorModifiers.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot PopStyleColor()
{ int current = g.StyleModifiers.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot PopStyleVar()
{ int current = g.FontStack.Size; if (write) *p_backup = current; else IM_ASSERT(*p_backup == current); p_backup++; } // User forgot PopFont()
IM_ASSERT(p_backup == window->DC.StackSizesBackup + IM_ARRAYSIZE(window->DC.StackSizesBackup));
}
static ImVec2 FindBestPopupWindowPos(const ImVec2& base_pos, const ImVec2& size, int* last_dir, const ImRect& r_inner)
{
const ImGuiStyle& style = GImGui->Style;
// Clamp into visible area while not overlapping the cursor. Safety padding is optional if our popup size won't fit without it.
ImVec2 safe_padding = style.DisplaySafeAreaPadding;
ImRect r_outer(GetVisibleRect());
r_outer.Reduce(ImVec2((size.x - r_outer.GetWidth() > safe_padding.x*2) ? safe_padding.x : 0.0f, (size.y - r_outer.GetHeight() > safe_padding.y*2) ? safe_padding.y : 0.0f));
ImVec2 base_pos_clamped = ImClamp(base_pos, r_outer.Min, r_outer.Max - size);
for (int n = (*last_dir != -1) ? -1 : 0; n < 4; n++) // Last, Right, down, up, left. (Favor last used direction).
{
const int dir = (n == -1) ? *last_dir : n;
ImRect rect(dir == 0 ? r_inner.Max.x : r_outer.Min.x, dir == 1 ? r_inner.Max.y : r_outer.Min.y, dir == 3 ? r_inner.Min.x : r_outer.Max.x, dir == 2 ? r_inner.Min.y : r_outer.Max.y);
if (rect.GetWidth() < size.x || rect.GetHeight() < size.y)
continue;
*last_dir = dir;
return ImVec2(dir == 0 ? r_inner.Max.x : dir == 3 ? r_inner.Min.x - size.x : base_pos_clamped.x, dir == 1 ? r_inner.Max.y : dir == 2 ? r_inner.Min.y - size.y : base_pos_clamped.y);
}
// Fallback, try to keep within display
*last_dir = -1;
ImVec2 pos = base_pos;
pos.x = ImMax(ImMin(pos.x + size.x, r_outer.Max.x) - size.x, r_outer.Min.x);
pos.y = ImMax(ImMin(pos.y + size.y, r_outer.Max.y) - size.y, r_outer.Min.y);
return pos;
}
ImGuiWindow* ImGui::FindWindowByName(const char* name)
{
// FIXME-OPT: Store sorted hashes -> pointers so we can do a bissection in a contiguous block
ImGuiState& g = *GImGui;
ImGuiID id = ImHash(name, 0);
for (int i = 0; i < g.Windows.Size; i++)
if (g.Windows[i]->ID == id)
return g.Windows[i];
return NULL;
}
static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags)
{
ImGuiState& g = *GImGui;
// Create window the first time
ImGuiWindow* window = (ImGuiWindow*)ImGui::MemAlloc(sizeof(ImGuiWindow));
IM_PLACEMENT_NEW(window) ImGuiWindow(name);
window->Flags = flags;
if (flags & ImGuiWindowFlags_NoSavedSettings)
{
// User can disable loading and saving of settings. Tooltip and child windows also don't store settings.
window->Size = window->SizeFull = size;
}
else
{
// Retrieve settings from .ini file
// Use SetWindowPos() or SetNextWindowPos() with the appropriate condition flag to change the initial position of a window.
window->PosFloat = ImVec2(60, 60);
window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
ImGuiIniData* settings = FindWindowSettings(name);
if (!settings)
{
settings = AddWindowSettings(name);
}
else
{
window->SetWindowPosAllowFlags &= ~ImGuiSetCond_FirstUseEver;
window->SetWindowSizeAllowFlags &= ~ImGuiSetCond_FirstUseEver;
window->SetWindowCollapsedAllowFlags &= ~ImGuiSetCond_FirstUseEver;
}
if (settings->Pos.x != FLT_MAX)
{
window->PosFloat = settings->Pos;
window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
window->Collapsed = settings->Collapsed;
}
if (ImLengthSqr(settings->Size) > 0.00001f && !(flags & ImGuiWindowFlags_NoResize))
size = settings->Size;
window->Size = window->SizeFull = size;
}
if ((flags & ImGuiWindowFlags_AlwaysAutoResize) != 0)
{
window->AutoFitFramesX = window->AutoFitFramesY = 2;
window->AutoFitOnlyGrows = false;
}
else
{
if (window->Size.x <= 0.0f)
window->AutoFitFramesX = 2;
if (window->Size.y <= 0.0f)
window->AutoFitFramesY = 2;
window->AutoFitOnlyGrows = (window->AutoFitFramesX > 0) || (window->AutoFitFramesY > 0);
}
if (flags & ImGuiWindowFlags_NoBringToFrontOnFocus)
g.Windows.insert(g.Windows.begin(), window); // Quite slow but rare and only once
else
g.Windows.push_back(window);
return window;
}
// Push a new ImGui window to add widgets to.
// - A default window called "Debug" is automatically stacked at the beginning of every frame so you can use widgets without explicitly calling a Begin/End pair.
// - Begin/End can be called multiple times during the frame with the same window name to append content.
// - 'size_on_first_use' for a regular window denote the initial size for first-time creation (no saved data) and isn't that useful. Use SetNextWindowSize() prior to calling Begin() for more flexible window manipulation.
// - The window name is used as a unique identifier to preserve window information across frames (and save rudimentary information to the .ini file).
// You can use the "##" or "###" markers to use the same label with different id, or same id with different label. See documentation at the top of this file.
// - Return false when window is collapsed, so you can early out in your code. You always need to call ImGui::End() even if false is returned.
// - Passing 'bool* p_opened' displays a Close button on the upper-right corner of the window, the pointed value will be set to false when the button is pressed.
// - Passing non-zero 'size' is roughly equivalent to calling SetNextWindowSize(size, ImGuiSetCond_FirstUseEver) prior to calling Begin().
bool ImGui::Begin(const char* name, bool* p_opened, ImGuiWindowFlags flags)
{
return ImGui::Begin(name, p_opened, ImVec2(0.f, 0.f), -1.0f, flags);
}
bool ImGui::Begin(const char* name, bool* p_opened, const ImVec2& size_on_first_use, float bg_alpha, ImGuiWindowFlags flags)
{
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
IM_ASSERT(name != NULL); // Window name required
IM_ASSERT(g.Initialized); // Forgot to call ImGui::NewFrame()
IM_ASSERT(g.FrameCountEnded != g.FrameCount); // Called ImGui::Render() or ImGui::EndFrame() and haven't called ImGui::NewFrame() again yet
if (flags & ImGuiWindowFlags_NoInputs)
flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize;
// Find or create
bool window_is_new = false;
ImGuiWindow* window = FindWindowByName(name);
if (!window)
{
window = CreateNewWindow(name, size_on_first_use, flags);
window_is_new = true;
}
const int current_frame = ImGui::GetFrameCount();
const bool first_begin_of_the_frame = (window->LastFrameActive != current_frame);
if (first_begin_of_the_frame)
window->Flags = (ImGuiWindowFlags)flags;
else
flags = window->Flags;
// Add to stack
ImGuiWindow* parent_window = !g.CurrentWindowStack.empty() ? g.CurrentWindowStack.back() : NULL;
g.CurrentWindowStack.push_back(window);
SetCurrentWindow(window);
CheckStacksSize(window, true);
IM_ASSERT(parent_window != NULL || !(flags & ImGuiWindowFlags_ChildWindow));
bool window_was_active = (window->LastFrameActive == current_frame - 1); // Not using !WasActive because the implicit "Debug" window would always toggle off->on
if (flags & ImGuiWindowFlags_Popup)
{
ImGuiPopupRef& popup_ref = g.OpenedPopupStack[g.CurrentPopupStack.Size];
window_was_active &= (window->PopupID == popup_ref.PopupID);
window_was_active &= (window == popup_ref.Window);
popup_ref.Window = window;
g.CurrentPopupStack.push_back(popup_ref);
window->PopupID = popup_ref.PopupID;
}
const bool window_appearing_after_being_hidden = (window->HiddenFrames == 1);
// Process SetNextWindow***() calls
bool window_pos_set_by_api = false, window_size_set_by_api = false;
if (g.SetNextWindowPosCond)
{
const ImVec2 backup_cursor_pos = window->DC.CursorPos; // FIXME: not sure of the exact reason of this anymore :( need to look into that.
if (!window_was_active || window_appearing_after_being_hidden) window->SetWindowPosAllowFlags |= ImGuiSetCond_Appearing;
window_pos_set_by_api = (window->SetWindowPosAllowFlags & g.SetNextWindowPosCond) != 0;
if (window_pos_set_by_api && ImLengthSqr(g.SetNextWindowPosVal - ImVec2(-FLT_MAX,-FLT_MAX)) < 0.001f)
{
window->SetWindowPosCenterWanted = true; // May be processed on the next frame if this is our first frame and we are measuring size
window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
}
else
{
SetWindowPos(window, g.SetNextWindowPosVal, g.SetNextWindowPosCond);
}
window->DC.CursorPos = backup_cursor_pos;
g.SetNextWindowPosCond = 0;
}
if (g.SetNextWindowSizeCond)
{
if (!window_was_active || window_appearing_after_being_hidden) window->SetWindowSizeAllowFlags |= ImGuiSetCond_Appearing;
window_size_set_by_api = (window->SetWindowSizeAllowFlags & g.SetNextWindowSizeCond) != 0;
SetWindowSize(window, g.SetNextWindowSizeVal, g.SetNextWindowSizeCond);
g.SetNextWindowSizeCond = 0;
}
if (g.SetNextWindowContentSizeCond)
{
window->SizeContentsExplicit = g.SetNextWindowContentSizeVal;
g.SetNextWindowContentSizeCond = 0;
}
else if (first_begin_of_the_frame)
{
window->SizeContentsExplicit = ImVec2(0.0f, 0.0f);
}
if (g.SetNextWindowCollapsedCond)
{
if (!window_was_active || window_appearing_after_being_hidden) window->SetWindowCollapsedAllowFlags |= ImGuiSetCond_Appearing;
SetWindowCollapsed(window, g.SetNextWindowCollapsedVal, g.SetNextWindowCollapsedCond);
g.SetNextWindowCollapsedCond = 0;
}
if (g.SetNextWindowFocus)
{
ImGui::SetWindowFocus();
g.SetNextWindowFocus = false;
}
// Update known root window (if we are a child window, otherwise window == window->RootWindow)
int root_idx, root_non_popup_idx;
for (root_idx = g.CurrentWindowStack.Size - 1; root_idx > 0; root_idx--)
if (!(g.CurrentWindowStack[root_idx]->Flags & ImGuiWindowFlags_ChildWindow))
break;
for (root_non_popup_idx = root_idx; root_non_popup_idx > 0; root_non_popup_idx--)
if (!(g.CurrentWindowStack[root_non_popup_idx]->Flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)))
break;
window->RootWindow = g.CurrentWindowStack[root_idx];
window->RootNonPopupWindow = g.CurrentWindowStack[root_non_popup_idx]; // This is merely for displaying the TitleBgActive color.
// When reusing window again multiple times a frame, just append content (don't need to setup again)
if (first_begin_of_the_frame)
{
window->Active = true;
window->BeginCount = 0;
window->DrawList->Clear();
window->ClipRect = ImVec4(-FLT_MAX,-FLT_MAX,+FLT_MAX,+FLT_MAX);
window->LastFrameActive = current_frame;
window->IDStack.resize(1);
// Setup texture, outer clipping rectangle
window->DrawList->PushTextureID(g.Font->ContainerAtlas->TexID);
ImRect fullscreen_rect(GetVisibleRect());
if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & (ImGuiWindowFlags_ComboBox|ImGuiWindowFlags_Popup)))
PushClipRect(parent_window->ClipRect.Min, parent_window->ClipRect.Max, true);
else
PushClipRect(fullscreen_rect.Min, fullscreen_rect.Max, true);
// New windows appears in front
if (!window_was_active)
{
window->AutoPosLastDirection = -1;
if (!(flags & ImGuiWindowFlags_NoFocusOnAppearing))
if (!(flags & (ImGuiWindowFlags_ChildWindow|ImGuiWindowFlags_Tooltip)) || (flags & ImGuiWindowFlags_Popup))
FocusWindow(window);
// Popup first latch mouse position, will position itself when it appears next frame
if ((flags & ImGuiWindowFlags_Popup) != 0 && !window_pos_set_by_api)
window->PosFloat = g.IO.MousePos;
}
// Collapse window by double-clicking on title bar
// At this point we don't have a clipping rectangle setup yet, so we can use the title bar area for hit detection and drawing
if (!(flags & ImGuiWindowFlags_NoTitleBar) && !(flags & ImGuiWindowFlags_NoCollapse))
{
ImRect title_bar_rect = window->TitleBarRect();
if (g.HoveredWindow == window && IsMouseHoveringRect(title_bar_rect.Min, title_bar_rect.Max) && g.IO.MouseDoubleClicked[0])
{
window->Collapsed = !window->Collapsed;
if (!(flags & ImGuiWindowFlags_NoSavedSettings))
MarkSettingsDirty();
FocusWindow(window);
}
}
else
{
window->Collapsed = false;
}
// SIZE
// Save contents size from last frame for auto-fitting (unless explicitly specified)
window->SizeContents.x = (float)(int)((window->SizeContentsExplicit.x != 0.0f) ? window->SizeContentsExplicit.x : ((window_is_new ? 0.0f : window->DC.CursorMaxPos.x - window->Pos.x) + window->Scroll.x));
window->SizeContents.y = (float)(int)((window->SizeContentsExplicit.y != 0.0f) ? window->SizeContentsExplicit.y : ((window_is_new ? 0.0f : window->DC.CursorMaxPos.y - window->Pos.y) + window->Scroll.y));
// Hide popup/tooltip window when first appearing while we measure size (because we recycle them)
if (window->HiddenFrames > 0)
window->HiddenFrames--;
if ((flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) != 0 && !window_was_active)
{
window->HiddenFrames = 1;
if (flags & ImGuiWindowFlags_AlwaysAutoResize)
{
if (!window_size_set_by_api)
window->Size = window->SizeFull = ImVec2(0.f, 0.f);
window->SizeContents = ImVec2(0.f, 0.f);
}
}
// Lock window padding so that altering the ShowBorders flag for children doesn't have side-effects.
window->WindowPadding = ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & (ImGuiWindowFlags_AlwaysUseWindowPadding | ImGuiWindowFlags_ShowBorders | ImGuiWindowFlags_ComboBox | ImGuiWindowFlags_Popup))) ? ImVec2(0,0) : style.WindowPadding;
// Calculate auto-fit size
ImVec2 size_auto_fit;
if ((flags & ImGuiWindowFlags_Tooltip) != 0)
{
// Tooltip always resize. We keep the spacing symmetric on both axises for aesthetic purpose.
size_auto_fit = window->SizeContents + window->WindowPadding - ImVec2(0.0f, style.ItemSpacing.y);
}
else
{
size_auto_fit = ImClamp(window->SizeContents + window->WindowPadding, style.WindowMinSize, ImMax(style.WindowMinSize, g.IO.DisplaySize - g.Style.DisplaySafeAreaPadding));
// Handling case of auto fit window not fitting in screen on one axis, we are growing auto fit size on the other axis to compensate for expected scrollbar. FIXME: Might turn bigger than DisplaySize-WindowPadding.
if (size_auto_fit.x < window->SizeContents.x && !(flags & ImGuiWindowFlags_NoScrollbar) && (flags & ImGuiWindowFlags_HorizontalScrollbar))
size_auto_fit.y += style.ScrollbarSize;
if (size_auto_fit.y < window->SizeContents.y && !(flags & ImGuiWindowFlags_NoScrollbar))
size_auto_fit.x += style.ScrollbarSize;
size_auto_fit.y = ImMax(size_auto_fit.y - style.ItemSpacing.y, 0.0f);
}
// Handle automatic resize
if (window->Collapsed)
{
// We still process initial auto-fit on collapsed windows to get a window width,
// But otherwise we don't honor ImGuiWindowFlags_AlwaysAutoResize when collapsed.
if (window->AutoFitFramesX > 0)
window->SizeFull.x = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.x, size_auto_fit.x) : size_auto_fit.x;
if (window->AutoFitFramesY > 0)
window->SizeFull.y = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.y, size_auto_fit.y) : size_auto_fit.y;
window->Size = window->TitleBarRect().GetSize();
}
else
{
if ((flags & ImGuiWindowFlags_AlwaysAutoResize) && !window_size_set_by_api)
{
window->SizeFull = size_auto_fit;
}
else if ((window->AutoFitFramesX > 0 || window->AutoFitFramesY > 0) && !window_size_set_by_api)
{
// Auto-fit only grows during the first few frames
if (window->AutoFitFramesX > 0)
window->SizeFull.x = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.x, size_auto_fit.x) : size_auto_fit.x;
if (window->AutoFitFramesY > 0)
window->SizeFull.y = window->AutoFitOnlyGrows ? ImMax(window->SizeFull.y, size_auto_fit.y) : size_auto_fit.y;
if (!(flags & ImGuiWindowFlags_NoSavedSettings))
MarkSettingsDirty();
}
window->Size = window->SizeFull;
}
// Minimum window size
if (!(flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_AlwaysAutoResize)))
{
window->SizeFull = ImMax(window->SizeFull, style.WindowMinSize);
if (!window->Collapsed)
window->Size = window->SizeFull;
}
// POSITION
// Position child window
if (flags & ImGuiWindowFlags_ChildWindow)
parent_window->DC.ChildWindows.push_back(window);
if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup))
{
window->Pos = window->PosFloat = parent_window->DC.CursorPos;
window->Size = window->SizeFull = size_on_first_use; // NB: argument name 'size_on_first_use' misleading here, it's really just 'size' as provided by user.
}
bool window_pos_center = false;
window_pos_center |= (window->SetWindowPosCenterWanted && window->HiddenFrames == 0);
window_pos_center |= ((flags & ImGuiWindowFlags_Modal) && !window_pos_set_by_api && window_appearing_after_being_hidden);
if (window_pos_center)
{
// Center (any sort of window)
SetWindowPos(ImMax(style.DisplaySafeAreaPadding, fullscreen_rect.GetCenter() - window->SizeFull * 0.5f));
}
else if (flags & ImGuiWindowFlags_ChildMenu)
{
IM_ASSERT(window_pos_set_by_api);
ImRect rect_to_avoid;
if (parent_window->DC.MenuBarAppending)
rect_to_avoid = ImRect(-FLT_MAX, parent_window->Pos.y + parent_window->TitleBarHeight(), FLT_MAX, parent_window->Pos.y + parent_window->TitleBarHeight() + parent_window->MenuBarHeight());
else
rect_to_avoid = ImRect(parent_window->Pos.x + style.ItemSpacing.x, -FLT_MAX, parent_window->Pos.x + parent_window->Size.x - style.ItemSpacing.x - parent_window->ScrollbarSizes.x, FLT_MAX); // We want some overlap to convey the relative depth of each popup (here hard-coded to 4)
window->PosFloat = FindBestPopupWindowPos(window->PosFloat, window->Size, &window->AutoPosLastDirection, rect_to_avoid);
}
else if ((flags & ImGuiWindowFlags_Popup) != 0 && !window_pos_set_by_api && window_appearing_after_being_hidden)
{
ImRect rect_to_avoid(window->PosFloat.x - 1, window->PosFloat.y - 1, window->PosFloat.x + 1, window->PosFloat.y + 1);
window->PosFloat = FindBestPopupWindowPos(window->PosFloat, window->Size, &window->AutoPosLastDirection, rect_to_avoid);
}
// Position tooltip (always follows mouse)
if ((flags & ImGuiWindowFlags_Tooltip) != 0 && !window_pos_set_by_api)
{
ImRect rect_to_avoid(g.IO.MousePos.x - 16, g.IO.MousePos.y - 8, g.IO.MousePos.x + 24, g.IO.MousePos.y + 24); // FIXME: Completely hard-coded. Perhaps center on cursor hit-point instead?
window->PosFloat = FindBestPopupWindowPos(g.IO.MousePos, window->Size, &window->AutoPosLastDirection, rect_to_avoid);
if (window->AutoPosLastDirection == -1)
window->PosFloat = g.IO.MousePos + ImVec2(2,2); // If there's not enough room, for tooltip we prefer avoiding the cursor at all cost even if it means that part of the tooltip won't be visible.
}
// User moving window (at the beginning of the frame to avoid input lag or sheering). Only valid for root windows.
KeepAliveID(window->MoveID);
if (g.ActiveId == window->MoveID)
{
if (g.IO.MouseDown[0])
{
if (!(flags & ImGuiWindowFlags_NoMove))
{
window->PosFloat += g.IO.MouseDelta;
if (!(flags & ImGuiWindowFlags_NoSavedSettings))
MarkSettingsDirty();
}
IM_ASSERT(g.MovedWindow != NULL);
FocusWindow(g.MovedWindow);
}
else
{
SetActiveID(0);
g.MovedWindow = NULL; // Not strictly necessary but doing it for sanity.
}
}
// Clamp position so it stays visible
if (!(flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Tooltip))
{
if (!window_pos_set_by_api && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0 && g.IO.DisplaySize.x > 0.0f && g.IO.DisplaySize.y > 0.0f) // Ignore zero-sized display explicitly to avoid losing positions if a window manager reports zero-sized window when initializing or minimizing.
{
ImVec2 padding = ImMax(style.DisplayWindowPadding, style.DisplaySafeAreaPadding);
window->PosFloat = ImMax(window->PosFloat + window->Size, padding) - window->Size;
window->PosFloat = ImMin(window->PosFloat, g.IO.DisplaySize - padding);
}
}
window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
// Default item width. Make it proportional to window size if window manually resizes
if (window->Size.x > 0.0f && !(flags & ImGuiWindowFlags_Tooltip) && !(flags & ImGuiWindowFlags_AlwaysAutoResize))
window->ItemWidthDefault = (float)(int)(window->Size.x * 0.65f);
else
window->ItemWidthDefault = (float)(int)(g.FontSize * 16.0f);
// Prepare for focus requests
window->FocusIdxAllRequestCurrent = (window->FocusIdxAllRequestNext == IM_INT_MAX || window->FocusIdxAllCounter == -1) ? IM_INT_MAX : (window->FocusIdxAllRequestNext + (window->FocusIdxAllCounter+1)) % (window->FocusIdxAllCounter+1);
window->FocusIdxTabRequestCurrent = (window->FocusIdxTabRequestNext == IM_INT_MAX || window->FocusIdxTabCounter == -1) ? IM_INT_MAX : (window->FocusIdxTabRequestNext + (window->FocusIdxTabCounter+1)) % (window->FocusIdxTabCounter+1);
window->FocusIdxAllCounter = window->FocusIdxTabCounter = -1;
window->FocusIdxAllRequestNext = window->FocusIdxTabRequestNext = IM_INT_MAX;
// Apply scrolling
if (window->ScrollTarget.x < FLT_MAX)
{
window->Scroll.x = window->ScrollTarget.x;
window->ScrollTarget.x = FLT_MAX;
}
if (window->ScrollTarget.y < FLT_MAX)
{
float center_ratio = window->ScrollTargetCenterRatio.y;
window->Scroll.y = window->ScrollTarget.y - ((1.0f - center_ratio) * window->TitleBarHeight()) - (center_ratio * window->SizeFull.y);
window->ScrollTarget.y = FLT_MAX;
}
window->Scroll = ImMax(window->Scroll, ImVec2(0.0f, 0.0f));
if (!window->Collapsed && !window->SkipItems)
window->Scroll = ImMin(window->Scroll, ImMax(ImVec2(0.0f, 0.0f), window->SizeContents - window->SizeFull + window->ScrollbarSizes));
// Modal window darkens what is behind them
if ((flags & ImGuiWindowFlags_Modal) != 0 && window == GetFrontMostModalRootWindow())
window->DrawList->AddRectFilled(fullscreen_rect.Min, fullscreen_rect.Max, GetColorU32(ImGuiCol_ModalWindowDarkening, g.ModalWindowDarkeningRatio));
// Draw window + handle manual resize
ImRect title_bar_rect = window->TitleBarRect();
const float window_rounding = (flags & ImGuiWindowFlags_ChildWindow) ? style.ChildWindowRounding : style.WindowRounding;
if (window->Collapsed)
{
// Draw title bar only
RenderFrame(title_bar_rect.GetTL(), title_bar_rect.GetBR(), GetColorU32(ImGuiCol_TitleBgCollapsed), true, window_rounding);
}
else
{
ImU32 resize_col = 0;
const float resize_corner_size = ImMax(g.FontSize * 1.35f, window_rounding + 1.0f + g.FontSize * 0.2f);
if (!(flags & ImGuiWindowFlags_AlwaysAutoResize) && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0 && !(flags & ImGuiWindowFlags_NoResize))
{
// Manual resize
const ImVec2 br = window->Rect().GetBR();
const ImRect resize_rect(br - ImVec2(resize_corner_size * 0.75f, resize_corner_size * 0.75f), br);
const ImGuiID resize_id = window->GetID("#RESIZE");
bool hovered, held;
ButtonBehavior(resize_rect, resize_id, &hovered, &held, ImGuiButtonFlags_FlattenChilds);
resize_col = GetColorU32(held ? ImGuiCol_ResizeGripActive : hovered ? ImGuiCol_ResizeGripHovered : ImGuiCol_ResizeGrip);
if (hovered || held)
g.MouseCursor = ImGuiMouseCursor_ResizeNWSE;
if (g.HoveredWindow == window && held && g.IO.MouseDoubleClicked[0])
{
// Manual auto-fit when double-clicking
window->SizeFull = size_auto_fit;
if (!(flags & ImGuiWindowFlags_NoSavedSettings))
MarkSettingsDirty();
SetActiveID(0);
}
else if (held)
{
window->SizeFull = ImMax(window->SizeFull + g.IO.MouseDelta, style.WindowMinSize);
if (!(flags & ImGuiWindowFlags_NoSavedSettings))
MarkSettingsDirty();
}
window->Size = window->SizeFull;
title_bar_rect = window->TitleBarRect();
}
// Scrollbars
window->ScrollbarY = (flags & ImGuiWindowFlags_AlwaysVerticalScrollbar) || ((window->SizeContents.y > window->Size.y + style.ItemSpacing.y) && !(flags & ImGuiWindowFlags_NoScrollbar));
window->ScrollbarX = (flags & ImGuiWindowFlags_AlwaysHorizontalScrollbar) || ((window->SizeContents.x > window->Size.x - (window->ScrollbarY ? style.ScrollbarSize : 0.0f) - window->WindowPadding.x) && !(flags & ImGuiWindowFlags_NoScrollbar) && (flags & ImGuiWindowFlags_HorizontalScrollbar));
window->ScrollbarSizes = ImVec2(window->ScrollbarY ? style.ScrollbarSize : 0.0f, window->ScrollbarX ? style.ScrollbarSize : 0.0f);
window->BorderSize = (flags & ImGuiWindowFlags_ShowBorders) ? 1.0f : 0.0f;
// Window background
// Default alpha
ImGuiCol bg_color_idx = ImGuiCol_WindowBg;
if ((flags & ImGuiWindowFlags_ComboBox) != 0)
bg_color_idx = ImGuiCol_ComboBg;
else if ((flags & ImGuiWindowFlags_Tooltip) != 0 || (flags & ImGuiWindowFlags_Popup) != 0)
bg_color_idx = ImGuiCol_PopupBg;
else if ((flags & ImGuiWindowFlags_ChildWindow) != 0)
bg_color_idx = ImGuiCol_ChildWindowBg;
ImVec4 bg_color = style.Colors[bg_color_idx];
if (bg_alpha >= 0.0f)
bg_color.w = bg_alpha;
bg_color.w *= style.Alpha;
if (bg_color.w > 0.0f)
window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, ColorConvertFloat4ToU32(bg_color), window_rounding);
// Title bar
if (!(flags & ImGuiWindowFlags_NoTitleBar))
window->DrawList->AddRectFilled(title_bar_rect.GetTL(), title_bar_rect.GetBR(), GetColorU32((g.FocusedWindow && window->RootNonPopupWindow == g.FocusedWindow->RootNonPopupWindow) ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBg), window_rounding, 1|2);
// Menu bar
if (flags & ImGuiWindowFlags_MenuBar)
{
ImRect menu_bar_rect = window->MenuBarRect();
window->DrawList->AddRectFilled(menu_bar_rect.GetTL(), menu_bar_rect.GetBR(), GetColorU32(ImGuiCol_MenuBarBg), (flags & ImGuiWindowFlags_NoTitleBar) ? window_rounding : 0.0f, 1|2);
}
// Scrollbars
if (window->ScrollbarX)
Scrollbar(window, true);
if (window->ScrollbarY)
Scrollbar(window, false);
// Render resize grip
// (after the input handling so we don't have a frame of latency)
if (!(flags & ImGuiWindowFlags_NoResize))
{
const ImVec2 br = window->Rect().GetBR();
window->DrawList->PathLineTo(br + ImVec2(-resize_corner_size, -window->BorderSize));
window->DrawList->PathLineTo(br + ImVec2(-window->BorderSize, -resize_corner_size));
window->DrawList->PathArcToFast(ImVec2(br.x - window_rounding - window->BorderSize, br.y - window_rounding - window->BorderSize), window_rounding, 0, 3);
window->DrawList->PathFill(resize_col);
}
// Borders
if (flags & ImGuiWindowFlags_ShowBorders)
{
window->DrawList->AddRect(window->Pos+ImVec2(1,1), window->Pos+window->Size+ImVec2(1,1), GetColorU32(ImGuiCol_BorderShadow), window_rounding);
window->DrawList->AddRect(window->Pos, window->Pos+window->Size, GetColorU32(ImGuiCol_Border), window_rounding);
if (!(flags & ImGuiWindowFlags_NoTitleBar))
window->DrawList->AddLine(title_bar_rect.GetBL()+ImVec2(1,0), title_bar_rect.GetBR()-ImVec2(1,0), GetColorU32(ImGuiCol_Border));
}
}
// Setup drawing context
window->DC.IndentX = 0.0f + window->WindowPadding.x - window->Scroll.x;
window->DC.ColumnsOffsetX = 0.0f;
window->DC.CursorStartPos = window->Pos + ImVec2(window->DC.IndentX + window->DC.ColumnsOffsetX, window->TitleBarHeight() + window->MenuBarHeight() + window->WindowPadding.y - window->Scroll.y);
window->DC.CursorPos = window->DC.CursorStartPos;
window->DC.CursorPosPrevLine = window->DC.CursorPos;
window->DC.CursorMaxPos = window->DC.CursorStartPos;
window->DC.CurrentLineHeight = window->DC.PrevLineHeight = 0.0f;
window->DC.CurrentLineTextBaseOffset = window->DC.PrevLineTextBaseOffset = 0.0f;
window->DC.MenuBarAppending = false;
window->DC.MenuBarOffsetX = ImMax(window->WindowPadding.x, style.ItemSpacing.x);
window->DC.LogLinePosY = window->DC.CursorPos.y - 9999.0f;
window->DC.ChildWindows.resize(0);
window->DC.LayoutType = ImGuiLayoutType_Vertical;
window->DC.ItemWidth = window->ItemWidthDefault;
window->DC.TextWrapPos = -1.0f; // disabled
window->DC.AllowKeyboardFocus = true;
window->DC.ButtonRepeat = false;
window->DC.ItemWidthStack.resize(0);
window->DC.TextWrapPosStack.resize(0);
window->DC.AllowKeyboardFocusStack.resize(0);
window->DC.ButtonRepeatStack.resize(0);
window->DC.ColorEditMode = ImGuiColorEditMode_UserSelect;
window->DC.ColumnsCurrent = 0;
window->DC.ColumnsCount = 1;
window->DC.ColumnsStartPosY = window->DC.CursorPos.y;
window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY = window->DC.ColumnsStartPosY;
window->DC.TreeDepth = 0;
window->DC.StateStorage = &window->StateStorage;
window->DC.GroupStack.resize(0);
window->MenuColumns.Update(3, style.ItemSpacing.x, !window_was_active);
if (window->AutoFitFramesX > 0)
window->AutoFitFramesX--;
if (window->AutoFitFramesY > 0)
window->AutoFitFramesY--;
// Title bar
if (!(flags & ImGuiWindowFlags_NoTitleBar))
{
if (p_opened != NULL)
CloseWindowButton(p_opened);
const ImVec2 text_size = CalcTextSize(name, NULL, true);
if (!(flags & ImGuiWindowFlags_NoCollapse))
RenderCollapseTriangle(window->Pos + style.FramePadding, !window->Collapsed, 1.0f, true);
ImVec2 text_min = window->Pos + style.FramePadding;
ImVec2 text_max = window->Pos + ImVec2(window->Size.x - style.FramePadding.x, style.FramePadding.y*2 + text_size.y);
ImVec2 clip_max = ImVec2(window->Pos.x + window->Size.x - (p_opened ? title_bar_rect.GetHeight() - 3 : style.FramePadding.x), text_max.y); // Match the size of CloseWindowButton()
bool pad_left = (flags & ImGuiWindowFlags_NoCollapse) == 0;
bool pad_right = (p_opened != NULL);
if (style.WindowTitleAlign & ImGuiAlign_Center) pad_right = pad_left;
if (pad_left) text_min.x += g.FontSize + style.ItemInnerSpacing.x;
if (pad_right) text_max.x -= g.FontSize + style.ItemInnerSpacing.x;
RenderTextClipped(text_min, text_max, name, NULL, &text_size, style.WindowTitleAlign, NULL, &clip_max);
}
// Save clipped aabb so we can access it in constant-time in FindHoveredWindow()
window->ClippedWindowRect = window->Rect();
window->ClippedWindowRect.Clip(window->ClipRect);
// Pressing CTRL+C while holding on a window copy its content to the clipboard
// This works but 1. doesn't handle multiple Begin/End pairs, 2. recursing into another Begin/End pair - so we need to work that out and add better logging scope.
// Maybe we can support CTRL+C on every element?
/*
if (g.ActiveId == move_id)
if (g.IO.KeyCtrl && IsKeyPressedMap(ImGuiKey_C))
ImGui::LogToClipboard();
*/
}
// Inner clipping rectangle
// We set this up after processing the resize grip so that our clip rectangle doesn't lag by a frame
// Note that if our window is collapsed we will end up with a null clipping rectangle which is the correct behavior.
const ImRect title_bar_rect = window->TitleBarRect();
const float border_size = window->BorderSize;
ImRect clip_rect;
clip_rect.Min.x = title_bar_rect.Min.x + 0.5f + ImMax(border_size, window->WindowPadding.x*0.5f);
clip_rect.Min.y = title_bar_rect.Max.y + window->MenuBarHeight() + 0.5f + border_size;
clip_rect.Max.x = window->Pos.x + window->Size.x - window->ScrollbarSizes.x - ImMax(border_size, window->WindowPadding.x*0.5f);
clip_rect.Max.y = window->Pos.y + window->Size.y - border_size - window->ScrollbarSizes.y;
PushClipRect(clip_rect.Min, clip_rect.Max, true);
// Clear 'accessed' flag last thing
if (first_begin_of_the_frame)
window->Accessed = false;
window->BeginCount++;
// Child window can be out of sight and have "negative" clip windows.
// Mark them as collapsed so commands are skipped earlier (we can't manually collapse because they have no title bar).
if (flags & ImGuiWindowFlags_ChildWindow)
{
IM_ASSERT((flags & ImGuiWindowFlags_NoTitleBar) != 0);
window->Collapsed = parent_window && parent_window->Collapsed;
if (!(flags & ImGuiWindowFlags_AlwaysAutoResize) && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0)
window->Collapsed |= (window->ClippedWindowRect.Min.x >= window->ClippedWindowRect.Max.x || window->ClippedWindowRect.Min.y >= window->ClippedWindowRect.Max.y);
// We also hide the window from rendering because we've already added its border to the command list.
// (we could perform the check earlier in the function but it is simpler at this point)
if (window->Collapsed)
window->Active = false;
}
if (style.Alpha <= 0.0f)
window->Active = false;
// Return false if we don't intend to display anything to allow user to perform an early out optimization
window->SkipItems = (window->Collapsed || !window->Active) && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0;
return !window->SkipItems;
}
void ImGui::End()
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGui::Columns(1, "#CloseColumns");
PopClipRect(); // inner window clip rectangle
// Stop logging
if (!(window->Flags & ImGuiWindowFlags_ChildWindow)) // FIXME: add more options for scope of logging
ImGui::LogFinish();
// Pop
// NB: we don't clear 'window->RootWindow'. The pointer is allowed to live until the next call to Begin().
g.CurrentWindowStack.pop_back();
if (window->Flags & ImGuiWindowFlags_Popup)
g.CurrentPopupStack.pop_back();
CheckStacksSize(window, false);
SetCurrentWindow(g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back());
}
// Vertical scrollbar
// The entire piece of code below is rather confusing because:
// - We handle absolute seeking (when first clicking outside the grab) and relative manipulation (afterward or when clicking inside the grab)
// - We store values as normalized ratio and in a form that allows the window content to change while we are holding on a scrollbar
// - We handle both horizontal and vertical scrollbars, which makes the terminology not ideal.
static void Scrollbar(ImGuiWindow* window, bool horizontal)
{
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(horizontal ? "#SCROLLX" : "#SCROLLY");
// Render background
bool other_scrollbar = (horizontal ? window->ScrollbarY : window->ScrollbarX);
float other_scrollbar_size_w = other_scrollbar ? style.ScrollbarSize : 0.0f;
const ImRect window_rect = window->Rect();
const float border_size = window->BorderSize;
ImRect bb = horizontal
? ImRect(window->Pos.x + border_size, window_rect.Max.y - style.ScrollbarSize, window_rect.Max.x - other_scrollbar_size_w - border_size, window_rect.Max.y - border_size)
: ImRect(window_rect.Max.x - style.ScrollbarSize, window->Pos.y + border_size, window_rect.Max.x - border_size, window_rect.Max.y - other_scrollbar_size_w - border_size);
if (!horizontal)
bb.Min.y += window->TitleBarHeight() + ((window->Flags & ImGuiWindowFlags_MenuBar) ? window->MenuBarHeight() - border_size : 0.0f);
float window_rounding = (window->Flags & ImGuiWindowFlags_ChildWindow) ? style.ChildWindowRounding : style.WindowRounding;
int window_rounding_corners;
if (horizontal)
window_rounding_corners = 8 | (other_scrollbar ? 0 : 4);
else
window_rounding_corners = ((window->Flags & ImGuiWindowFlags_NoTitleBar) ? 2 : 0) | (other_scrollbar ? 0 : 4);
window->DrawList->AddRectFilled(bb.Min, bb.Max, ImGui::GetColorU32(ImGuiCol_ScrollbarBg), window_rounding, window_rounding_corners);
bb.Reduce(ImVec2(ImClamp((float)(int)((bb.Max.x - bb.Min.x - 2.0f) * 0.5f), 0.0f, 3.0f), ImClamp((float)(int)((bb.Max.y - bb.Min.y - 2.0f) * 0.5f), 0.0f, 3.0f)));
// V denote the main axis of the scrollbar
float scrollbar_size_v = horizontal ? bb.GetWidth() : bb.GetHeight();
float scroll_v = horizontal ? window->Scroll.x : window->Scroll.y;
float win_size_avail_v = (horizontal ? window->Size.x : window->Size.y) - other_scrollbar_size_w;
float win_size_contents_v = horizontal ? window->SizeContents.x : window->SizeContents.y;
// The grabable box size generally represent the amount visible (vs the total scrollable amount)
// But we maintain a minimum size in pixel to allow for the user to still aim inside.
const float grab_h_pixels = ImMin(ImMax(scrollbar_size_v * ImSaturate(win_size_avail_v / ImMax(win_size_contents_v, win_size_avail_v)), style.GrabMinSize), scrollbar_size_v);
const float grab_h_norm = grab_h_pixels / scrollbar_size_v;
// Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().
bool held = false;
bool hovered = false;
const bool previously_held = (g.ActiveId == id);
ImGui::ButtonBehavior(bb, id, &hovered, &held);
float scroll_max = ImMax(1.0f, win_size_contents_v - win_size_avail_v);
float scroll_ratio = ImSaturate(scroll_v / scroll_max);
float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;
if (held && grab_h_norm < 1.0f)
{
float scrollbar_pos_v = horizontal ? bb.Min.x : bb.Min.y;
float mouse_pos_v = horizontal ? g.IO.MousePos.x : g.IO.MousePos.y;
float* click_delta_to_grab_center_v = horizontal ? &g.ScrollbarClickDeltaToGrabCenter.x : &g.ScrollbarClickDeltaToGrabCenter.y;
// Click position in scrollbar normalized space (0.0f->1.0f)
const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);
ImGui::SetHoveredID(id);
bool seek_absolute = false;
if (!previously_held)
{
// On initial click calculate the distance between mouse and the center of the grab
if (clicked_v_norm >= grab_v_norm && clicked_v_norm <= grab_v_norm + grab_h_norm)
{
*click_delta_to_grab_center_v = clicked_v_norm - grab_v_norm - grab_h_norm*0.5f;
}
else
{
seek_absolute = true;
*click_delta_to_grab_center_v = 0.0f;
}
}
// Apply scroll
// It is ok to modify Scroll here because we are being called in Begin() after the calculation of SizeContents and before setting up our starting position
const float scroll_v_norm = ImSaturate((clicked_v_norm - *click_delta_to_grab_center_v - grab_h_norm*0.5f) / (1.0f - grab_h_norm));
scroll_v = (float)(int)(0.5f + scroll_v_norm * scroll_max);//(win_size_contents_v - win_size_v));
if (horizontal)
window->Scroll.x = scroll_v;
else
window->Scroll.y = scroll_v;
// Update values for rendering
scroll_ratio = ImSaturate(scroll_v / scroll_max);
grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;
// Update distance to grab now that we have seeked and saturated
if (seek_absolute)
*click_delta_to_grab_center_v = clicked_v_norm - grab_v_norm - grab_h_norm*0.5f;
}
// Render
const ImU32 grab_col = ImGui::GetColorU32(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab);
if (horizontal)
window->DrawList->AddRectFilled(ImVec2(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm), bb.Min.y), ImVec2(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm) + grab_h_pixels, bb.Max.y), grab_col, style.ScrollbarRounding);
else
window->DrawList->AddRectFilled(ImVec2(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm)), ImVec2(bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm) + grab_h_pixels), grab_col, style.ScrollbarRounding);
}
// Moving window to front of display (which happens to be back of our sorted list)
void ImGui::FocusWindow(ImGuiWindow* window)
{
ImGuiState& g = *GImGui;
// Always mark the window we passed as focused. This is used for keyboard interactions such as tabbing.
g.FocusedWindow = window;
// Passing NULL allow to disable keyboard focus
if (!window)
return;
// And move its root window to the top of the pile
if (window->RootWindow)
window = window->RootWindow;
// Steal focus on active widgets
if (window->Flags & ImGuiWindowFlags_Popup) // FIXME: This statement should be unnecessary. Need further testing before removing it..
if (g.ActiveId != 0 && g.ActiveIdWindow && g.ActiveIdWindow->RootWindow != window)
ImGui::SetActiveID(0);
// Bring to front
if ((window->Flags & ImGuiWindowFlags_NoBringToFrontOnFocus) || g.Windows.back() == window)
return;
for (int i = 0; i < g.Windows.Size; i++)
if (g.Windows[i] == window)
{
g.Windows.erase(g.Windows.begin() + i);
break;
}
g.Windows.push_back(window);
}
void ImGui::PushItemWidth(float item_width)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.ItemWidth = (item_width == 0.0f ? window->ItemWidthDefault : item_width);
window->DC.ItemWidthStack.push_back(window->DC.ItemWidth);
}
static void PushMultiItemsWidths(int components, float w_full)
{
ImGuiWindow* window = ImGui::GetCurrentWindow();
const ImGuiStyle& style = GImGui->Style;
if (w_full <= 0.0f)
w_full = ImGui::CalcItemWidth();
const float w_item_one = ImMax(1.0f, (float)(int)((w_full - (style.ItemInnerSpacing.x) * (components-1)) / (float)components));
const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.ItemInnerSpacing.x) * (components-1)));
window->DC.ItemWidthStack.push_back(w_item_last);
for (int i = 0; i < components-1; i++)
window->DC.ItemWidthStack.push_back(w_item_one);
window->DC.ItemWidth = window->DC.ItemWidthStack.back();
}
void ImGui::PopItemWidth()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.ItemWidthStack.pop_back();
window->DC.ItemWidth = window->DC.ItemWidthStack.empty() ? window->ItemWidthDefault : window->DC.ItemWidthStack.back();
}
float ImGui::CalcItemWidth()
{
ImGuiWindow* window = GetCurrentWindowRead();
float w = window->DC.ItemWidth;
if (w < 0.0f)
{
// Align to a right-side limit. We include 1 frame padding in the calculation because this is how the width is always used (we add 2 frame padding to it), but we could move that responsibility to the widget as well.
float width_to_right_edge = ImGui::GetContentRegionAvail().x;
w = ImMax(1.0f, width_to_right_edge + w);
}
w = (float)(int)w;
return w;
}
static void SetCurrentFont(ImFont* font)
{
ImGuiState& g = *GImGui;
IM_ASSERT(font && font->IsLoaded()); // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
IM_ASSERT(font->Scale > 0.0f);
g.Font = font;
g.FontBaseSize = g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale;
g.FontSize = g.CurrentWindow ? g.CurrentWindow->CalcFontSize() : 0.0f;
g.FontTexUvWhitePixel = g.Font->ContainerAtlas->TexUvWhitePixel;
}
void ImGui::PushFont(ImFont* font)
{
ImGuiState& g = *GImGui;
if (!font)
font = g.IO.Fonts->Fonts[0];
SetCurrentFont(font);
g.FontStack.push_back(font);
g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}
void ImGui::PopFont()
{
ImGuiState& g = *GImGui;
g.CurrentWindow->DrawList->PopTextureID();
g.FontStack.pop_back();
SetCurrentFont(g.FontStack.empty() ? g.IO.Fonts->Fonts[0] : g.FontStack.back());
}
void ImGui::PushAllowKeyboardFocus(bool allow_keyboard_focus)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.AllowKeyboardFocus = allow_keyboard_focus;
window->DC.AllowKeyboardFocusStack.push_back(allow_keyboard_focus);
}
void ImGui::PopAllowKeyboardFocus()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.AllowKeyboardFocusStack.pop_back();
window->DC.AllowKeyboardFocus = window->DC.AllowKeyboardFocusStack.empty() ? true : window->DC.AllowKeyboardFocusStack.back();
}
void ImGui::PushButtonRepeat(bool repeat)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.ButtonRepeat = repeat;
window->DC.ButtonRepeatStack.push_back(repeat);
}
void ImGui::PopButtonRepeat()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.ButtonRepeatStack.pop_back();
window->DC.ButtonRepeat = window->DC.ButtonRepeatStack.empty() ? false : window->DC.ButtonRepeatStack.back();
}
void ImGui::PushTextWrapPos(float wrap_pos_x)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.TextWrapPos = wrap_pos_x;
window->DC.TextWrapPosStack.push_back(wrap_pos_x);
}
void ImGui::PopTextWrapPos()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.TextWrapPosStack.pop_back();
window->DC.TextWrapPos = window->DC.TextWrapPosStack.empty() ? -1.0f : window->DC.TextWrapPosStack.back();
}
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
ImGuiState& g = *GImGui;
ImGuiColMod backup;
backup.Col = idx;
backup.PreviousValue = g.Style.Colors[idx];
g.ColorModifiers.push_back(backup);
g.Style.Colors[idx] = col;
}
void ImGui::PopStyleColor(int count)
{
ImGuiState& g = *GImGui;
while (count > 0)
{
ImGuiColMod& backup = g.ColorModifiers.back();
g.Style.Colors[backup.Col] = backup.PreviousValue;
g.ColorModifiers.pop_back();
count--;
}
}
static float* GetStyleVarFloatAddr(ImGuiStyleVar idx)
{
ImGuiState& g = *GImGui;
switch (idx)
{
case ImGuiStyleVar_Alpha: return &g.Style.Alpha;
case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding;
case ImGuiStyleVar_ChildWindowRounding: return &g.Style.ChildWindowRounding;
case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding;
case ImGuiStyleVar_IndentSpacing: return &g.Style.IndentSpacing;
case ImGuiStyleVar_GrabMinSize: return &g.Style.GrabMinSize;
}
return NULL;
}
static ImVec2* GetStyleVarVec2Addr(ImGuiStyleVar idx)
{
ImGuiState& g = *GImGui;
switch (idx)
{
case ImGuiStyleVar_WindowPadding: return &g.Style.WindowPadding;
case ImGuiStyleVar_WindowMinSize: return &g.Style.WindowMinSize;
case ImGuiStyleVar_FramePadding: return &g.Style.FramePadding;
case ImGuiStyleVar_ItemSpacing: return &g.Style.ItemSpacing;
case ImGuiStyleVar_ItemInnerSpacing: return &g.Style.ItemInnerSpacing;
}
return NULL;
}
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
ImGuiState& g = *GImGui;
float* pvar = GetStyleVarFloatAddr(idx);
IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a float.
ImGuiStyleMod backup;
backup.Var = idx;
backup.PreviousValue = ImVec2(*pvar, 0.0f);
g.StyleModifiers.push_back(backup);
*pvar = val;
}
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
ImGuiState& g = *GImGui;
ImVec2* pvar = GetStyleVarVec2Addr(idx);
IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
ImGuiStyleMod backup;
backup.Var = idx;
backup.PreviousValue = *pvar;
g.StyleModifiers.push_back(backup);
*pvar = val;
}
void ImGui::PopStyleVar(int count)
{
ImGuiState& g = *GImGui;
while (count > 0)
{
ImGuiStyleMod& backup = g.StyleModifiers.back();
if (float* pvar_f = GetStyleVarFloatAddr(backup.Var))
*pvar_f = backup.PreviousValue.x;
else if (ImVec2* pvar_v = GetStyleVarVec2Addr(backup.Var))
*pvar_v = backup.PreviousValue;
g.StyleModifiers.pop_back();
count--;
}
}
const char* ImGui::GetStyleColName(ImGuiCol idx)
{
// Create switch-case from enum with regexp: ImGuiCol_{.*}, --> case ImGuiCol_\1: return "\1";
switch (idx)
{
case ImGuiCol_Text: return "Text";
case ImGuiCol_TextDisabled: return "TextDisabled";
case ImGuiCol_WindowBg: return "WindowBg";
case ImGuiCol_ChildWindowBg: return "ChildWindowBg";
case ImGuiCol_PopupBg: return "PopupBg";
case ImGuiCol_Border: return "Border";
case ImGuiCol_BorderShadow: return "BorderShadow";
case ImGuiCol_FrameBg: return "FrameBg";
case ImGuiCol_FrameBgHovered: return "FrameBgHovered";
case ImGuiCol_FrameBgActive: return "FrameBgActive";
case ImGuiCol_TitleBg: return "TitleBg";
case ImGuiCol_TitleBgCollapsed: return "TitleBgCollapsed";
case ImGuiCol_TitleBgActive: return "TitleBgActive";
case ImGuiCol_MenuBarBg: return "MenuBarBg";
case ImGuiCol_ScrollbarBg: return "ScrollbarBg";
case ImGuiCol_ScrollbarGrab: return "ScrollbarGrab";
case ImGuiCol_ScrollbarGrabHovered: return "ScrollbarGrabHovered";
case ImGuiCol_ScrollbarGrabActive: return "ScrollbarGrabActive";
case ImGuiCol_ComboBg: return "ComboBg";
case ImGuiCol_CheckMark: return "CheckMark";
case ImGuiCol_SliderGrab: return "SliderGrab";
case ImGuiCol_SliderGrabActive: return "SliderGrabActive";
case ImGuiCol_Button: return "Button";
case ImGuiCol_ButtonHovered: return "ButtonHovered";
case ImGuiCol_ButtonActive: return "ButtonActive";
case ImGuiCol_Header: return "Header";
case ImGuiCol_HeaderHovered: return "HeaderHovered";
case ImGuiCol_HeaderActive: return "HeaderActive";
case ImGuiCol_Column: return "Column";
case ImGuiCol_ColumnHovered: return "ColumnHovered";
case ImGuiCol_ColumnActive: return "ColumnActive";
case ImGuiCol_ResizeGrip: return "ResizeGrip";
case ImGuiCol_ResizeGripHovered: return "ResizeGripHovered";
case ImGuiCol_ResizeGripActive: return "ResizeGripActive";
case ImGuiCol_CloseButton: return "CloseButton";
case ImGuiCol_CloseButtonHovered: return "CloseButtonHovered";
case ImGuiCol_CloseButtonActive: return "CloseButtonActive";
case ImGuiCol_PlotLines: return "PlotLines";
case ImGuiCol_PlotLinesHovered: return "PlotLinesHovered";
case ImGuiCol_PlotHistogram: return "PlotHistogram";
case ImGuiCol_PlotHistogramHovered: return "PlotHistogramHovered";
case ImGuiCol_TextSelectedBg: return "TextSelectedBg";
case ImGuiCol_ModalWindowDarkening: return "ModalWindowDarkening";
}
IM_ASSERT(0);
return "Unknown";
}
bool ImGui::IsWindowHovered()
{
ImGuiState& g = *GImGui;
return g.HoveredWindow == g.CurrentWindow && IsWindowContentHoverable(g.HoveredRootWindow);
}
bool ImGui::IsWindowFocused()
{
ImGuiState& g = *GImGui;
return g.FocusedWindow == g.CurrentWindow;
}
bool ImGui::IsRootWindowFocused()
{
ImGuiState& g = *GImGui;
ImGuiWindow* root_window = g.CurrentWindow->RootWindow;
return g.FocusedWindow == root_window;
}
bool ImGui::IsRootWindowOrAnyChildFocused()
{
ImGuiState& g = *GImGui;
ImGuiWindow* root_window = g.CurrentWindow->RootWindow;
return g.FocusedWindow && g.FocusedWindow->RootWindow == root_window;
}
float ImGui::GetWindowWidth()
{
ImGuiWindow* window = GImGui->CurrentWindow;
return window->Size.x;
}
float ImGui::GetWindowHeight()
{
ImGuiWindow* window = GImGui->CurrentWindow;
return window->Size.y;
}
ImVec2 ImGui::GetWindowPos()
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
return window->Pos;
}
static void SetWindowScrollY(ImGuiWindow* window, float new_scroll_y)
{
window->DC.CursorMaxPos.y += window->Scroll.y;
window->Scroll.y = new_scroll_y;
window->DC.CursorMaxPos.y -= window->Scroll.y;
}
static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond)
{
// Test condition (NB: bit 0 is always true) and clear flags for next time
if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
return;
window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
window->SetWindowPosCenterWanted = false;
// Set
const ImVec2 old_pos = window->Pos;
window->PosFloat = pos;
window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
window->DC.CursorPos += (window->Pos - old_pos); // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
window->DC.CursorMaxPos += (window->Pos - old_pos); // And more importantly we need to adjust this so size calculation doesn't get affected.
}
void ImGui::SetWindowPos(const ImVec2& pos, ImGuiSetCond cond)
{
ImGuiWindow* window = GetCurrentWindow();
SetWindowPos(window, pos, cond);
}
void ImGui::SetWindowPos(const char* name, const ImVec2& pos, ImGuiSetCond cond)
{
ImGuiWindow* window = FindWindowByName(name);
if (window)
SetWindowPos(window, pos, cond);
}
ImVec2 ImGui::GetWindowSize()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->Size;
}
static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond)
{
// Test condition (NB: bit 0 is always true) and clear flags for next time
if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
return;
window->SetWindowSizeAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
// Set
if (size.x > 0.0f)
{
window->AutoFitFramesX = 0;
window->SizeFull.x = size.x;
}
else
{
window->AutoFitFramesX = 2;
window->AutoFitOnlyGrows = false;
}
if (size.y > 0.0f)
{
window->AutoFitFramesY = 0;
window->SizeFull.y = size.y;
}
else
{
window->AutoFitFramesY = 2;
window->AutoFitOnlyGrows = false;
}
}
void ImGui::SetWindowSize(const ImVec2& size, ImGuiSetCond cond)
{
SetWindowSize(GImGui->CurrentWindow, size, cond);
}
void ImGui::SetWindowSize(const char* name, const ImVec2& size, ImGuiSetCond cond)
{
ImGuiWindow* window = FindWindowByName(name);
if (window)
SetWindowSize(window, size, cond);
}
static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond)
{
// Test condition (NB: bit 0 is always true) and clear flags for next time
if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
return;
window->SetWindowCollapsedAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
// Set
window->Collapsed = collapsed;
}
void ImGui::SetWindowCollapsed(bool collapsed, ImGuiSetCond cond)
{
SetWindowCollapsed(GImGui->CurrentWindow, collapsed, cond);
}
bool ImGui::IsWindowCollapsed()
{
return GImGui->CurrentWindow->Collapsed;
}
void ImGui::SetWindowCollapsed(const char* name, bool collapsed, ImGuiSetCond cond)
{
ImGuiWindow* window = FindWindowByName(name);
if (window)
SetWindowCollapsed(window, collapsed, cond);
}
void ImGui::SetWindowFocus()
{
FocusWindow(GImGui->CurrentWindow);
}
void ImGui::SetWindowFocus(const char* name)
{
if (name)
{
ImGuiWindow* window = FindWindowByName(name);
if (window)
FocusWindow(window);
}
else
{
FocusWindow(NULL);
}
}
void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiSetCond cond)
{
ImGuiState& g = *GImGui;
g.SetNextWindowPosVal = pos;
g.SetNextWindowPosCond = cond ? cond : ImGuiSetCond_Always;
}
void ImGui::SetNextWindowPosCenter(ImGuiSetCond cond)
{
ImGuiState& g = *GImGui;
g.SetNextWindowPosVal = ImVec2(-FLT_MAX, -FLT_MAX);
g.SetNextWindowPosCond = cond ? cond : ImGuiSetCond_Always;
}
void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiSetCond cond)
{
ImGuiState& g = *GImGui;
g.SetNextWindowSizeVal = size;
g.SetNextWindowSizeCond = cond ? cond : ImGuiSetCond_Always;
}
void ImGui::SetNextWindowContentSize(const ImVec2& size)
{
ImGuiState& g = *GImGui;
g.SetNextWindowContentSizeVal = size;
g.SetNextWindowContentSizeCond = ImGuiSetCond_Always;
}
void ImGui::SetNextWindowContentWidth(float width)
{
ImGuiState& g = *GImGui;
g.SetNextWindowContentSizeVal = ImVec2(width, g.SetNextWindowContentSizeCond ? g.SetNextWindowContentSizeVal.y : 0.0f);
g.SetNextWindowContentSizeCond = ImGuiSetCond_Always;
}
void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond)
{
ImGuiState& g = *GImGui;
g.SetNextWindowCollapsedVal = collapsed;
g.SetNextWindowCollapsedCond = cond ? cond : ImGuiSetCond_Always;
}
void ImGui::SetNextWindowFocus()
{
ImGuiState& g = *GImGui;
g.SetNextWindowFocus = true;
}
// In window space (not screen space!)
// FIXME-OPT: Could cache and maintain it (pretty much only change on columns change)
ImVec2 ImGui::GetContentRegionMax()
{
ImGuiWindow* window = GetCurrentWindowRead();
ImVec2 content_region_size = ImVec2(window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x - window->ScrollbarSizes.x, window->SizeContentsExplicit.y ? window->SizeContentsExplicit.y : window->Size.y - window->ScrollbarSizes.y);
ImVec2 mx = content_region_size - window->Scroll - window->WindowPadding;
if (window->DC.ColumnsCount != 1)
mx.x = ImGui::GetColumnOffset(window->DC.ColumnsCurrent + 1) - window->WindowPadding.x;
return mx;
}
ImVec2 ImGui::GetContentRegionAvail()
{
ImGuiWindow* window = GetCurrentWindowRead();
return GetContentRegionMax() - (window->DC.CursorPos - window->Pos);
}
float ImGui::GetContentRegionAvailWidth()
{
return GetContentRegionAvail().x;
}
// In window space (not screen space!)
ImVec2 ImGui::GetWindowContentRegionMin()
{
ImGuiWindow* window = GetCurrentWindowRead();
return ImVec2(-window->Scroll.x, -window->Scroll.y + window->TitleBarHeight() + window->MenuBarHeight()) + window->WindowPadding;
}
ImVec2 ImGui::GetWindowContentRegionMax()
{
ImGuiWindow* window = GetCurrentWindowRead();
ImVec2 content_region_size = ImVec2(window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x, window->SizeContentsExplicit.y ? window->SizeContentsExplicit.y : window->Size.y);
ImVec2 m = content_region_size - window->Scroll - window->WindowPadding - window->ScrollbarSizes;
return m;
}
float ImGui::GetWindowContentRegionWidth()
{
return GetWindowContentRegionMax().x - GetWindowContentRegionMin().x;
}
float ImGui::GetTextLineHeight()
{
ImGuiState& g = *GImGui;
return g.FontSize;
}
float ImGui::GetTextLineHeightWithSpacing()
{
ImGuiState& g = *GImGui;
return g.FontSize + g.Style.ItemSpacing.y;
}
float ImGui::GetItemsLineHeightWithSpacing()
{
ImGuiState& g = *GImGui;
return g.FontSize + g.Style.FramePadding.y * 2.0f + g.Style.ItemSpacing.y;
}
ImDrawList* ImGui::GetWindowDrawList()
{
ImGuiWindow* window = GetCurrentWindow();
return window->DrawList;
}
ImFont* ImGui::GetFont()
{
return GImGui->Font;
}
float ImGui::GetFontSize()
{
return GImGui->FontSize;
}
ImVec2 ImGui::GetFontTexUvWhitePixel()
{
return GImGui->FontTexUvWhitePixel;
}
void ImGui::SetWindowFontScale(float scale)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
window->FontWindowScale = scale;
g.FontSize = window->CalcFontSize();
}
// User generally sees positions in window coordinates. Internally we store CursorPos in absolute screen coordinates because it is more convenient.
// Conversion happens as we pass the value to user, but it makes our naming convention confusing because GetCursorPos() == (DC.CursorPos - window.Pos). May want to rename 'DC.CursorPos'.
ImVec2 ImGui::GetCursorPos()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.CursorPos - window->Pos + window->Scroll;
}
float ImGui::GetCursorPosX()
{
ImGuiWindow* window = GetCurrentWindow();
return window->DC.CursorPos.x - window->Pos.x + window->Scroll.x;
}
float ImGui::GetCursorPosY()
{
ImGuiWindow* window = GetCurrentWindow();
return window->DC.CursorPos.y - window->Pos.y + window->Scroll.y;
}
void ImGui::SetCursorPos(const ImVec2& local_pos)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.CursorPos = window->Pos - window->Scroll + local_pos;
window->DC.CursorMaxPos = ImMax(window->DC.CursorMaxPos, window->DC.CursorPos);
}
void ImGui::SetCursorPosX(float x)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + x;
window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPos.x);
}
void ImGui::SetCursorPosY(float y)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.CursorPos.y = window->Pos.y - window->Scroll.y + y;
window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y);
}
ImVec2 ImGui::GetCursorStartPos()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.CursorStartPos - window->Pos;
}
ImVec2 ImGui::GetCursorScreenPos()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.CursorPos;
}
void ImGui::SetCursorScreenPos(const ImVec2& screen_pos)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.CursorPos = screen_pos;
}
float ImGui::GetScrollX()
{
return GImGui->CurrentWindow->Scroll.x;
}
float ImGui::GetScrollY()
{
return GImGui->CurrentWindow->Scroll.y;
}
float ImGui::GetScrollMaxX()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->SizeContents.x - window->SizeFull.x - window->ScrollbarSizes.x;
}
float ImGui::GetScrollMaxY()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->SizeContents.y - window->SizeFull.y - window->ScrollbarSizes.y;
}
void ImGui::SetScrollX(float scroll_x)
{
ImGuiWindow* window = GetCurrentWindow();
window->ScrollTarget.x = scroll_x;
window->ScrollTargetCenterRatio.x = 0.0f;
}
void ImGui::SetScrollY(float scroll_y)
{
ImGuiWindow* window = GetCurrentWindow();
window->ScrollTarget.y = scroll_y + window->TitleBarHeight(); // title bar height canceled out when using ScrollTargetRelY
window->ScrollTargetCenterRatio.y = 0.0f;
}
void ImGui::SetScrollFromPosY(float pos_y, float center_y_ratio)
{
// We store a target position so centering can occur on the next frame when we are guaranteed to have a known window size
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
window->ScrollTarget.y = (float)(int)(pos_y + window->Scroll.y);
if (center_y_ratio <= 0.0f && window->ScrollTarget.y <= window->WindowPadding.y) // Minor hack to make "scroll to top" take account of WindowPadding, else it would scroll to (WindowPadding.y - ItemSpacing.y)
window->ScrollTarget.y = 0.0f;
window->ScrollTargetCenterRatio.y = center_y_ratio;
}
// center_y_ratio: 0.0f top of last item, 0.5f vertical center of last item, 1.0f bottom of last item.
void ImGui::SetScrollHere(float center_y_ratio)
{
ImGuiWindow* window = GetCurrentWindow();
float target_y = window->DC.CursorPosPrevLine.y + (window->DC.PrevLineHeight * center_y_ratio) + (GImGui->Style.ItemSpacing.y * (center_y_ratio - 0.5f) * 2.0f); // Precisely aim above, in the middle or below the last line.
ImGui::SetScrollFromPosY(target_y - window->Pos.y, center_y_ratio);
}
void ImGui::SetKeyboardFocusHere(int offset)
{
ImGuiWindow* window = GetCurrentWindow();
window->FocusIdxAllRequestNext = window->FocusIdxAllCounter + 1 + offset;
window->FocusIdxTabRequestNext = IM_INT_MAX;
}
void ImGui::SetStateStorage(ImGuiStorage* tree)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.StateStorage = tree ? tree : &window->StateStorage;
}
ImGuiStorage* ImGui::GetStateStorage()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.StateStorage;
}
void ImGui::TextV(const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
TextUnformatted(g.TempBuffer, text_end);
}
void ImGui::Text(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
TextV(fmt, args);
va_end(args);
}
void ImGui::TextColoredV(const ImVec4& col, const char* fmt, va_list args)
{
ImGui::PushStyleColor(ImGuiCol_Text, col);
TextV(fmt, args);
ImGui::PopStyleColor();
}
void ImGui::TextColored(const ImVec4& col, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
TextColoredV(col, fmt, args);
va_end(args);
}
void ImGui::TextDisabledV(const char* fmt, va_list args)
{
ImGui::PushStyleColor(ImGuiCol_Text, GImGui->Style.Colors[ImGuiCol_TextDisabled]);
TextV(fmt, args);
ImGui::PopStyleColor();
}
void ImGui::TextDisabled(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
TextDisabledV(fmt, args);
va_end(args);
}
void ImGui::TextWrappedV(const char* fmt, va_list args)
{
ImGui::PushTextWrapPos(0.0f);
TextV(fmt, args);
ImGui::PopTextWrapPos();
}
void ImGui::TextWrapped(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
TextWrappedV(fmt, args);
va_end(args);
}
void ImGui::TextUnformatted(const char* text, const char* text_end)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
IM_ASSERT(text != NULL);
const char* text_begin = text;
if (text_end == NULL)
text_end = text + strlen(text); // FIXME-OPT
const float wrap_pos_x = window->DC.TextWrapPos;
const bool wrap_enabled = wrap_pos_x >= 0.0f;
if (text_end - text > 2000 && !wrap_enabled)
{
// Long text!
// Perform manual coarse clipping to optimize for long multi-line text
// From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled.
// We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line.
const char* line = text;
const float line_height = ImGui::GetTextLineHeight();
const ImVec2 text_pos = window->DC.CursorPos + ImVec2(0.0f, window->DC.CurrentLineTextBaseOffset);
const ImRect clip_rect = window->ClipRect;
ImVec2 text_size(0,0);
if (text_pos.y <= clip_rect.Max.y)
{
ImVec2 pos = text_pos;
// Lines to skip (can't skip when logging text)
if (!g.LogEnabled)
{
int lines_skippable = (int)((clip_rect.Min.y - text_pos.y) / line_height);
if (lines_skippable > 0)
{
int lines_skipped = 0;
while (line < text_end && lines_skipped < lines_skippable)
{
const char* line_end = strchr(line, '\n');
if (!line_end)
line_end = text_end;
line = line_end + 1;
lines_skipped++;
}
pos.y += lines_skipped * line_height;
}
}
// Lines to render
if (line < text_end)
{
ImRect line_rect(pos, pos + ImVec2(ImGui::GetWindowWidth(), line_height));
while (line < text_end)
{
const char* line_end = strchr(line, '\n');
if (IsClippedEx(line_rect, NULL, false))
break;
const ImVec2 line_size = CalcTextSize(line, line_end, false);
text_size.x = ImMax(text_size.x, line_size.x);
RenderText(pos, line, line_end, false);
if (!line_end)
line_end = text_end;
line = line_end + 1;
line_rect.Min.y += line_height;
line_rect.Max.y += line_height;
pos.y += line_height;
}
// Count remaining lines
int lines_skipped = 0;
while (line < text_end)
{
const char* line_end = strchr(line, '\n');
if (!line_end)
line_end = text_end;
line = line_end + 1;
lines_skipped++;
}
pos.y += lines_skipped * line_height;
}
text_size.y += (pos - text_pos).y;
}
ImRect bb(text_pos, text_pos + text_size);
ItemSize(bb);
ItemAdd(bb, NULL);
}
else
{
const float wrap_width = wrap_enabled ? CalcWrapWidthForPos(window->DC.CursorPos, wrap_pos_x) : 0.0f;
const ImVec2 text_size = CalcTextSize(text_begin, text_end, false, wrap_width);
// Account of baseline offset
ImVec2 text_pos = window->DC.CursorPos;
text_pos.y += window->DC.CurrentLineTextBaseOffset;
ImRect bb(text_pos, text_pos + text_size);
ItemSize(text_size);
if (!ItemAdd(bb, NULL))
return;
// Render (we don't hide text after ## in this end-user function)
RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width);
}
}
void ImGui::AlignFirstTextHeightToWidgets()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
// Declare a dummy item size to that upcoming items that are smaller will center-align on the newly expanded line height.
ImGuiState& g = *GImGui;
ItemSize(ImVec2(0, g.FontSize + g.Style.FramePadding.y*2), g.Style.FramePadding.y);
ImGui::SameLine(0, 0);
}
// Add a label+text combo aligned to other label+value widgets
void ImGui::LabelTextV(const char* label, const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const float w = CalcItemWidth();
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect value_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y*2));
const ImRect total_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x : 0.0f), style.FramePadding.y*2) + label_size);
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, NULL))
return;
// Render
const char* value_text_begin = &g.TempBuffer[0];
const char* value_text_end = value_text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
RenderTextClipped(value_bb.Min, value_bb.Max, value_text_begin, value_text_end, NULL, ImGuiAlign_VCenter);
if (label_size.x > 0.0f)
RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y + style.FramePadding.y), label);
}
void ImGui::LabelText(const char* label, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
LabelTextV(label, fmt, args);
va_end(args);
}
static inline bool IsWindowContentHoverable(ImGuiWindow* window)
{
// An active popup disable hovering on other windows (apart from its own children)
ImGuiState& g = *GImGui;
if (ImGuiWindow* focused_window = g.FocusedWindow)
if (ImGuiWindow* focused_root_window = focused_window->RootWindow)
if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) != 0 && focused_root_window->WasActive && focused_root_window != window->RootWindow)
return false;
return true;
}
bool ImGui::ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
if (flags & ImGuiButtonFlags_Disabled)
{
if (out_hovered) *out_hovered = false;
if (out_held) *out_held = false;
if (g.ActiveId == id) SetActiveID(0);
return false;
}
bool pressed = false;
const bool hovered = IsHovered(bb, id, (flags & ImGuiButtonFlags_FlattenChilds) != 0);
if (hovered)
{
SetHoveredID(id);
if (!(flags & ImGuiButtonFlags_NoKeyModifiers) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt))
{
if (g.IO.MouseDoubleClicked[0] && (flags & ImGuiButtonFlags_PressedOnDoubleClick))
{
pressed = true;
}
else if (g.IO.MouseClicked[0])
{
if (flags & ImGuiButtonFlags_PressedOnClick)
{
pressed = true;
SetActiveID(0);
}
else
{
SetActiveID(id, window);
}
FocusWindow(window);
}
else if (g.IO.MouseReleased[0] && (flags & ImGuiButtonFlags_PressedOnRelease))
{
pressed = true;
SetActiveID(0);
}
else if ((flags & ImGuiButtonFlags_Repeat) && g.ActiveId == id && ImGui::IsMouseClicked(0, true))
{
pressed = true;
}
}
}
bool held = false;
if (g.ActiveId == id)
{
if (g.IO.MouseDown[0])
{
held = true;
}
else
{
if (hovered)
pressed = true;
SetActiveID(0);
}
}
if (out_hovered) *out_hovered = hovered;
if (out_held) *out_held = held;
return pressed;
}
bool ImGui::ButtonEx(const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
ImVec2 pos = window->DC.CursorPos;
if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrentLineTextBaseOffset)
pos.y += window->DC.CurrentLineTextBaseOffset - style.FramePadding.y;
ImVec2 size = CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);
const ImRect bb(pos, pos + size);
ItemSize(bb, style.FramePadding.y);
if (!ItemAdd(bb, &id))
return false;
if (window->DC.ButtonRepeat) flags |= ImGuiButtonFlags_Repeat;
bool hovered, held;
bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);
// Render
const ImU32 col = GetColorU32((hovered && held) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
RenderTextClipped(bb.Min, bb.Max, label, NULL, &label_size, ImGuiAlign_Center | ImGuiAlign_VCenter);
// Automatically close popups
//if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))
// ImGui::CloseCurrentPopup();
return pressed;
}
bool ImGui::Button(const char* label, const ImVec2& size_arg)
{
return ButtonEx(label, size_arg, 0);
}
// Small buttons fits within text without additional vertical spacing.
bool ImGui::SmallButton(const char* label)
{
ImGuiState& g = *GImGui;
float backup_padding_y = g.Style.FramePadding.y;
g.Style.FramePadding.y = 0.0f;
bool pressed = ButtonEx(label, ImVec2(0,0), ImGuiButtonFlags_AlignTextBaseLine);
g.Style.FramePadding.y = backup_padding_y;
return pressed;
}
// Tip: use ImGui::PushID()/PopID() to push indices or pointers in the ID stack.
// Then you can keep 'str_id' empty or the same for all your buttons (instead of creating a string based on a non-string id)
bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
const ImGuiID id = window->GetID(str_id);
ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
ItemSize(bb);
if (!ItemAdd(bb, &id))
return false;
bool hovered, held;
bool pressed = ButtonBehavior(bb, id, &hovered, &held);
return pressed;
}
// Upper-right button to close a window.
static bool CloseWindowButton(bool* p_opened)
{
ImGuiWindow* window = ImGui::GetCurrentWindow();
const ImGuiID id = window->GetID("#CLOSE");
const float size = window->TitleBarHeight() - 4.0f;
const ImRect bb(window->Rect().GetTR() + ImVec2(-2.0f-size,2.0f), window->Rect().GetTR() + ImVec2(-2.0f,2.0f+size));
bool hovered, held;
bool pressed = ImGui::ButtonBehavior(bb, id, &hovered, &held);
// Render
const ImU32 col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_CloseButtonActive : hovered ? ImGuiCol_CloseButtonHovered : ImGuiCol_CloseButton);
const ImVec2 center = bb.GetCenter();
window->DrawList->AddCircleFilled(center, ImMax(2.0f,size*0.5f), col, 16);
const float cross_extent = (size * 0.5f * 0.7071f) - 1.0f;
if (hovered)
{
window->DrawList->AddLine(center + ImVec2(+cross_extent,+cross_extent), center + ImVec2(-cross_extent,-cross_extent), ImGui::GetColorU32(ImGuiCol_Text));
window->DrawList->AddLine(center + ImVec2(+cross_extent,-cross_extent), center + ImVec2(-cross_extent,+cross_extent), ImGui::GetColorU32(ImGuiCol_Text));
}
if (p_opened != NULL && pressed)
*p_opened = false;
return pressed;
}
void ImGui::Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col, const ImVec4& border_col)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
if (border_col.w > 0.0f)
bb.Max += ImVec2(2,2);
ItemSize(bb);
if (!ItemAdd(bb, NULL))
return;
if (border_col.w > 0.0f)
{
window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(border_col), 0.0f);
window->DrawList->AddImage(user_texture_id, bb.Min+ImVec2(1,1), bb.Max-ImVec2(1,1), uv0, uv1, GetColorU32(tint_col));
}
else
{
window->DrawList->AddImage(user_texture_id, bb.Min, bb.Max, uv0, uv1, GetColorU32(tint_col));
}
}
// frame_padding < 0: uses FramePadding from style (default)
// frame_padding = 0: no framing
// frame_padding > 0: set framing size
// The color used are the button colors.
bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
// Default to using texture ID as ID. User can still push string/integer prefixes.
// We could hash the size/uv to create a unique ID but that would prevent the user from animating UV.
ImGui::PushID((void *)user_texture_id);
const ImGuiID id = window->GetID("#image");
ImGui::PopID();
const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : style.FramePadding;
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size + padding*2);
const ImRect image_bb(window->DC.CursorPos + padding, window->DC.CursorPos + padding + size);
ItemSize(bb);
if (!ItemAdd(bb, &id))
return false;
bool hovered, held;
bool pressed = ButtonBehavior(bb, id, &hovered, &held);
// Render
const ImU32 col = GetColorU32((hovered && held) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
RenderFrame(bb.Min, bb.Max, col, true, ImClamp((float)ImMin(padding.x, padding.y), 0.0f, style.FrameRounding));
if (bg_col.w > 0.0f)
window->DrawList->AddRectFilled(image_bb.Min, image_bb.Max, GetColorU32(bg_col));
window->DrawList->AddImage(user_texture_id, image_bb.Min, image_bb.Max, uv0, uv1, GetColorU32(tint_col));
return pressed;
}
// Start logging ImGui output to TTY
void ImGui::LogToTTY(int max_depth)
{
ImGuiState& g = *GImGui;
if (g.LogEnabled)
return;
ImGuiWindow* window = GetCurrentWindowRead();
g.LogEnabled = true;
g.LogFile = stdout;
g.LogStartDepth = window->DC.TreeDepth;
if (max_depth >= 0)
g.LogAutoExpandMaxDepth = max_depth;
}
// Start logging ImGui output to given file
void ImGui::LogToFile(int max_depth, const char* filename)
{
ImGuiState& g = *GImGui;
if (g.LogEnabled)
return;
ImGuiWindow* window = GetCurrentWindowRead();
if (!filename)
{
filename = g.IO.LogFilename;
if (!filename)
return;
}
g.LogFile = fopen(filename, "ab");
if (!g.LogFile)
{
IM_ASSERT(g.LogFile != NULL); // Consider this an error
return;
}
g.LogEnabled = true;
g.LogStartDepth = window->DC.TreeDepth;
if (max_depth >= 0)
g.LogAutoExpandMaxDepth = max_depth;
}
// Start logging ImGui output to clipboard
void ImGui::LogToClipboard(int max_depth)
{
ImGuiState& g = *GImGui;
if (g.LogEnabled)
return;
ImGuiWindow* window = GetCurrentWindowRead();
g.LogEnabled = true;
g.LogFile = NULL;
g.LogStartDepth = window->DC.TreeDepth;
if (max_depth >= 0)
g.LogAutoExpandMaxDepth = max_depth;
}
void ImGui::LogFinish()
{
ImGuiState& g = *GImGui;
if (!g.LogEnabled)
return;
ImGui::LogText(IM_NEWLINE);
g.LogEnabled = false;
if (g.LogFile != NULL)
{
if (g.LogFile == stdout)
fflush(g.LogFile);
else
fclose(g.LogFile);
g.LogFile = NULL;
}
if (g.LogClipboard->size() > 1)
{
if (g.IO.SetClipboardTextFn)
g.IO.SetClipboardTextFn(g.LogClipboard->begin());
g.LogClipboard->clear();
}
}
// Helper to display logging buttons
void ImGui::LogButtons()
{
ImGuiState& g = *GImGui;
ImGui::PushID("LogButtons");
const bool log_to_tty = ImGui::Button("Log To TTY");
ImGui::SameLine();
const bool log_to_file = ImGui::Button("Log To File");
ImGui::SameLine();
const bool log_to_clipboard = ImGui::Button("Log To Clipboard");
ImGui::SameLine();
ImGui::PushItemWidth(80.0f);
ImGui::PushAllowKeyboardFocus(false);
ImGui::SliderInt("Depth", &g.LogAutoExpandMaxDepth, 0, 9, NULL);
ImGui::PopAllowKeyboardFocus();
ImGui::PopItemWidth();
ImGui::PopID();
// Start logging at the end of the function so that the buttons don't appear in the log
if (log_to_tty)
LogToTTY(g.LogAutoExpandMaxDepth);
if (log_to_file)
LogToFile(g.LogAutoExpandMaxDepth, g.IO.LogFilename);
if (log_to_clipboard)
LogToClipboard(g.LogAutoExpandMaxDepth);
}
bool ImGui::TreeNodeBehaviorIsOpened(ImGuiID id, ImGuiTreeNodeFlags flags)
{
// We only write to the tree storage if the user clicks (or explicitely use SetNextTreeNode*** functions)
ImGuiState& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiStorage* storage = window->DC.StateStorage;
bool opened;
if (g.SetNextTreeNodeOpenedCond != 0)
{
if (g.SetNextTreeNodeOpenedCond & ImGuiSetCond_Always)
{
opened = g.SetNextTreeNodeOpenedVal;
storage->SetInt(id, opened);
}
else
{
// We treat ImGuiSetCondition_Once and ImGuiSetCondition_FirstUseEver the same because tree node state are not saved persistently.
const int stored_value = storage->GetInt(id, -1);
if (stored_value == -1)
{
opened = g.SetNextTreeNodeOpenedVal;
storage->SetInt(id, opened);
}
else
{
opened = stored_value != 0;
}
}
g.SetNextTreeNodeOpenedCond = 0;
}
else
{
opened = storage->GetInt(id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;
}
// When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).
// NB- If we are above max depth we still allow manually opened nodes to be logged.
if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoExpandOnLog) && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
opened = true;
return opened;
}
// FIXME: Split into CollapsingHeader(label, default_open?) and TreeNodeBehavior(label), obsolete the 4 parameters function.
bool ImGui::CollapsingHeader(const char* label, const char* str_id, bool display_frame, bool default_open)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImVec2 padding = display_frame ? style.FramePadding : ImVec2(style.FramePadding.x, 0.0f);
IM_ASSERT(str_id != NULL || label != NULL);
if (str_id == NULL)
str_id = label;
if (label == NULL)
label = str_id;
const bool label_hide_text_after_double_hash = (label == str_id); // Only search and hide text after ## if we have passed label and ID separately, otherwise allow "##" within format string.
const ImGuiID id = window->GetID(str_id);
const ImVec2 label_size = CalcTextSize(label, NULL, label_hide_text_after_double_hash);
// We vertically grow up to current line height up the typical widget height.
const float text_base_offset_y = ImMax(0.0f, window->DC.CurrentLineTextBaseOffset - padding.y); // Latch before ItemSize changes it
const float frame_height = ImMax(ImMin(window->DC.CurrentLineHeight, g.FontSize + g.Style.FramePadding.y*2), label_size.y + padding.y*2);
ImRect bb = ImRect(window->DC.CursorPos, ImVec2(window->Pos.x + GetContentRegionMax().x, window->DC.CursorPos.y + frame_height));
if (display_frame)
{
// Framed header expand a little outside the default padding
bb.Min.x -= (float)(int)(window->WindowPadding.x*0.5f) - 1;
bb.Max.x += (float)(int)(window->WindowPadding.x*0.5f) - 1;
}
const float collapser_width = g.FontSize + (display_frame ? padding.x*2 : padding.x);
const float text_width = g.FontSize + (label_size.x > 0.0f ? label_size.x + padding.x*2 : 0.0f); // Include collapser
ItemSize(ImVec2(text_width, frame_height), text_base_offset_y);
// For regular tree nodes, we arbitrary allow to click past 2 worth of ItemSpacing
// (Ideally we'd want to add a flag for the user to specify we want want the hit test to be done up to the right side of the content or not)
const ImRect interact_bb = display_frame ? bb : ImRect(bb.Min.x, bb.Min.y, bb.Min.x + text_width + style.ItemSpacing.x*2, bb.Max.y);
bool opened = TreeNodeBehaviorIsOpened(id, (default_open ? ImGuiTreeNodeFlags_DefaultOpen : 0) | (display_frame ? ImGuiTreeNodeFlags_NoAutoExpandOnLog : 0));
if (!ItemAdd(interact_bb, &id))
return opened;
bool hovered, held;
bool pressed = ButtonBehavior(interact_bb, id, &hovered, &held, ImGuiButtonFlags_NoKeyModifiers);
if (pressed)
{
opened = !opened;
window->DC.StateStorage->SetInt(id, opened);
}
// Render
const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
const ImVec2 text_pos = bb.Min + padding + ImVec2(collapser_width, text_base_offset_y);
if (display_frame)
{
// Framed type
RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
RenderCollapseTriangle(bb.Min + padding + ImVec2(0.0f, text_base_offset_y), opened, 1.0f, true);
if (g.LogEnabled)
{
// NB: '##' is normally used to hide text (as a library-wide feature), so we need to specify the text range to make sure the ## aren't stripped out here.
const char log_prefix[] = "\n##";
const char log_suffix[] = "##";
LogRenderedText(text_pos, log_prefix, log_prefix+3);
RenderTextClipped(text_pos, bb.Max, label, NULL, &label_size);
LogRenderedText(text_pos, log_suffix+1, log_suffix+3);
}
else
{
RenderTextClipped(text_pos, bb.Max, label, NULL, &label_size);
}
}
else
{
// Unframed typed for tree nodes
if (hovered)
RenderFrame(bb.Min, bb.Max, col, false);
RenderCollapseTriangle(bb.Min + ImVec2(padding.x, g.FontSize*0.15f + text_base_offset_y), opened, 0.70f, false);
if (g.LogEnabled)
LogRenderedText(text_pos, ">");
RenderText(text_pos, label, NULL, label_hide_text_after_double_hash);
}
return opened;
}
void ImGui::Bullet()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const float line_height = ImMax(ImMin(window->DC.CurrentLineHeight, g.FontSize + g.Style.FramePadding.y*2), g.FontSize);
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize, line_height));
ItemSize(bb);
if (!ItemAdd(bb, NULL))
{
ImGui::SameLine(0, style.FramePadding.x*2);
return;
}
// Render
const float bullet_size = g.FontSize*0.15f;
window->DrawList->AddCircleFilled(bb.Min + ImVec2(style.FramePadding.x + g.FontSize*0.5f, line_height*0.5f), bullet_size, GetColorU32(ImGuiCol_Text));
// Stay on same line
ImGui::SameLine(0, style.FramePadding.x*2);
}
// Text with a little bullet aligned to the typical tree node.
void ImGui::BulletTextV(const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const char* text_begin = g.TempBuffer;
const char* text_end = text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
const ImVec2 label_size = CalcTextSize(text_begin, text_end, true);
const float text_base_offset_y = ImMax(0.0f, window->DC.CurrentLineTextBaseOffset); // Latch before ItemSize changes it
const float line_height = ImMax(ImMin(window->DC.CurrentLineHeight, g.FontSize + g.Style.FramePadding.y*2), g.FontSize);
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x*2) : 0.0f), ImMax(line_height, label_size.y))); // Empty text doesn't add padding
ItemSize(bb);
if (!ItemAdd(bb, NULL))
return;
// Render
const float bullet_size = g.FontSize*0.15f;
window->DrawList->AddCircleFilled(bb.Min + ImVec2(style.FramePadding.x + g.FontSize*0.5f, line_height*0.5f), bullet_size, GetColorU32(ImGuiCol_Text));
RenderText(bb.Min+ImVec2(g.FontSize + style.FramePadding.x*2, text_base_offset_y), text_begin, text_end);
}
void ImGui::BulletText(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
BulletTextV(fmt, args);
va_end(args);
}
// If returning 'true' the node is open and the user is responsible for calling TreePop
bool ImGui::TreeNodeV(const char* str_id, const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
if (!str_id || !str_id[0])
str_id = fmt;
ImGui::PushID(str_id);
const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
ImGui::PopID();
if (opened)
ImGui::TreePush(str_id);
return opened;
}
bool ImGui::TreeNode(const char* str_id, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
bool s = TreeNodeV(str_id, fmt, args);
va_end(args);
return s;
}
// If returning 'true' the node is open and the user is responsible for calling TreePop
bool ImGui::TreeNodeV(const void* ptr_id, const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
if (!ptr_id)
ptr_id = fmt;
ImGui::PushID(ptr_id);
const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
ImGui::PopID();
if (opened)
ImGui::TreePush(ptr_id);
return opened;
}
bool ImGui::TreeNode(const void* ptr_id, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
bool s = TreeNodeV(ptr_id, fmt, args);
va_end(args);
return s;
}
bool ImGui::TreeNode(const char* str_label_id)
{
return TreeNode(str_label_id, "%s", str_label_id);
}
void ImGui::SetNextTreeNodeOpened(bool opened, ImGuiSetCond cond)
{
ImGuiState& g = *GImGui;
g.SetNextTreeNodeOpenedVal = opened;
g.SetNextTreeNodeOpenedCond = cond ? cond : ImGuiSetCond_Always;
}
void ImGui::PushID(const char* str_id)
{
ImGuiWindow* window = GetCurrentWindow();
window->IDStack.push_back(window->GetID(str_id));
}
void ImGui::PushID(const char* str_id_begin, const char* str_id_end)
{
ImGuiWindow* window = GetCurrentWindow();
window->IDStack.push_back(window->GetID(str_id_begin, str_id_end));
}
void ImGui::PushID(const void* ptr_id)
{
ImGuiWindow* window = GetCurrentWindow();
window->IDStack.push_back(window->GetID(ptr_id));
}
void ImGui::PushID(int int_id)
{
const void* ptr_id = (void*)(intptr_t)int_id;
ImGuiWindow* window = GetCurrentWindow();
window->IDStack.push_back(window->GetID(ptr_id));
}
void ImGui::PopID()
{
ImGuiWindow* window = GetCurrentWindow();
window->IDStack.pop_back();
}
ImGuiID ImGui::GetID(const char* str_id)
{
return GImGui->CurrentWindow->GetID(str_id);
}
ImGuiID ImGui::GetID(const char* str_id_begin, const char* str_id_end)
{
return GImGui->CurrentWindow->GetID(str_id_begin, str_id_end);
}
ImGuiID ImGui::GetID(const void* ptr_id)
{
return GImGui->CurrentWindow->GetID(ptr_id);
}
static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, const char* display_format, char* buf, int buf_size)
{
if (data_type == ImGuiDataType_Int)
ImFormatString(buf, buf_size, display_format, *(int*)data_ptr);
else if (data_type == ImGuiDataType_Float)
ImFormatString(buf, buf_size, display_format, *(float*)data_ptr);
}
static inline void DataTypeFormatString(ImGuiDataType data_type, void* data_ptr, int decimal_precision, char* buf, int buf_size)
{
if (data_type == ImGuiDataType_Int)
{
if (decimal_precision < 0)
ImFormatString(buf, buf_size, "%d", *(int*)data_ptr);
else
ImFormatString(buf, buf_size, "%.*d", decimal_precision, *(int*)data_ptr);
}
else if (data_type == ImGuiDataType_Float)
{
if (decimal_precision < 0)
ImFormatString(buf, buf_size, "%f", *(float*)data_ptr); // Ideally we'd have a minimum decimal precision of 1 to visually denote that it is a float, while hiding non-significant digits?
else
ImFormatString(buf, buf_size, "%.*f", decimal_precision, *(float*)data_ptr);
}
}
static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* value1, const void* value2)// Store into value1
{
if (data_type == ImGuiDataType_Int)
{
if (op == '+')
*(int*)value1 = *(int*)value1 + *(const int*)value2;
else if (op == '-')
*(int*)value1 = *(int*)value1 - *(const int*)value2;
}
else if (data_type == ImGuiDataType_Float)
{
if (op == '+')
*(float*)value1 = *(float*)value1 + *(const float*)value2;
else if (op == '-')
*(float*)value1 = *(float*)value1 - *(const float*)value2;
}
}
// User can input math operators (e.g. +100) to edit a numerical values.
static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* data_ptr, const char* scalar_format)
{
while (ImCharIsSpace(*buf))
buf++;
// We don't support '-' op because it would conflict with inputing negative value.
// Instead you can use +-100 to subtract from an existing value
char op = buf[0];
if (op == '+' || op == '*' || op == '/')
{
buf++;
while (ImCharIsSpace(*buf))
buf++;
}
else
{
op = 0;
}
if (!buf[0])
return false;
if (data_type == ImGuiDataType_Int)
{
if (!scalar_format)
scalar_format = "%d";
int* v = (int*)data_ptr;
const int old_v = *v;
int arg0 = *v;
if (op && sscanf(initial_value_buf, scalar_format, &arg0) < 1)
return false;
// Store operand in a float so we can use fractional value for multipliers (*1.1), but constant always parsed as integer so we can fit big integers (e.g. 2000000003) past float precision
float arg1 = 0.0f;
if (op == '+') { if (sscanf(buf, "%f", &arg1) == 1) *v = (int)(arg0 + arg1); } // Add (use "+-" to subtract)
else if (op == '*') { if (sscanf(buf, "%f", &arg1) == 1) *v = (int)(arg0 * arg1); } // Multiply
else if (op == '/') { if (sscanf(buf, "%f", &arg1) == 1 && arg1 != 0.0f) *v = (int)(arg0 / arg1); }// Divide
else { if (sscanf(buf, scalar_format, &arg0) == 1) *v = arg0; } // Assign constant
return (old_v != *v);
}
else if (data_type == ImGuiDataType_Float)
{
// For floats we have to ignore format with precision (e.g. "%.2f") because sscanf doesn't take them in
scalar_format = "%f";
float* v = (float*)data_ptr;
const float old_v = *v;
float arg0 = *v;
if (op && sscanf(initial_value_buf, scalar_format, &arg0) < 1)
return false;
float arg1 = 0.0f;
if (sscanf(buf, scalar_format, &arg1) < 1)
return false;
if (op == '+') { *v = arg0 + arg1; } // Add (use "+-" to subtract)
else if (op == '*') { *v = arg0 * arg1; } // Multiply
else if (op == '/') { if (arg1 != 0.0f) *v = arg0 / arg1; } // Divide
else { *v = arg1; } // Assign constant
return (old_v != *v);
}
return false;
}
// Create text input in place of a slider (when CTRL+Clicking on slider)
bool ImGui::InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
// Our replacement widget will override the focus ID (registered previously to allow for a TAB focus to happen)
SetActiveID(g.ScalarAsInputTextId, window);
SetHoveredID(0);
FocusableItemUnregister(window);
char buf[32];
DataTypeFormatString(data_type, data_ptr, decimal_precision, buf, IM_ARRAYSIZE(buf));
bool text_value_changed = InputTextEx(label, buf, IM_ARRAYSIZE(buf), aabb.GetSize(), ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_AutoSelectAll);
if (g.ScalarAsInputTextId == 0)
{
// First frame
IM_ASSERT(g.ActiveId == id); // InputText ID expected to match the Slider ID (else we'd need to store them both, which is also possible)
g.ScalarAsInputTextId = g.ActiveId;
SetHoveredID(id);
}
else if (g.ActiveId != g.ScalarAsInputTextId)
{
// Release
g.ScalarAsInputTextId = 0;
}
if (text_value_changed)
return DataTypeApplyOpFromText(buf, GImGui->InputTextState.InitialText.begin(), data_type, data_ptr, NULL);
return false;
}
// Parse display precision back from the display format string
int ImGui::ParseFormatPrecision(const char* fmt, int default_precision)
{
int precision = default_precision;
while ((fmt = strchr(fmt, '%')) != NULL)
{
fmt++;
if (fmt[0] == '%') { fmt++; continue; } // Ignore "%%"
while (*fmt >= '0' && *fmt <= '9')
fmt++;
if (*fmt == '.')
{
precision = atoi(fmt + 1);
if (precision < 0 || precision > 10)
precision = default_precision;
}
break;
}
return precision;
}
float ImGui::RoundScalar(float value, int decimal_precision)
{
// Round past decimal precision
// So when our value is 1.99999 with a precision of 0.001 we'll end up rounding to 2.0
// FIXME: Investigate better rounding methods
static const float min_steps[10] = { 1.0f, 0.1f, 0.01f, 0.001f, 0.0001f, 0.00001f, 0.000001f, 0.0000001f, 0.00000001f, 0.000000001f };
float min_step = (decimal_precision >= 0 && decimal_precision < 10) ? min_steps[decimal_precision] : powf(10.0f, (float)-decimal_precision);
bool negative = value < 0.0f;
value = fabsf(value);
float remainder = fmodf(value, min_step);
if (remainder <= min_step*0.5f)
value -= remainder;
else
value += (min_step - remainder);
return negative ? -value : value;
}
bool ImGui::SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, ImGuiSliderFlags flags)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
const ImGuiStyle& style = g.Style;
// Draw frame
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
const bool is_non_linear = fabsf(power - 1.0f) > 0.0001f;
const bool is_horizontal = (flags & ImGuiSliderFlags_Vertical) == 0;
const float grab_padding = 2.0f;
const float slider_sz = is_horizontal ? (frame_bb.GetWidth() - grab_padding * 2.0f) : (frame_bb.GetHeight() - grab_padding * 2.0f);
float grab_sz;
if (decimal_precision > 0)
grab_sz = ImMin(style.GrabMinSize, slider_sz);
else
grab_sz = ImMin(ImMax(1.0f * (slider_sz / (v_max-v_min+1.0f)), style.GrabMinSize), slider_sz); // Integer sliders, if possible have the grab size represent 1 unit
const float slider_usable_sz = slider_sz - grab_sz;
const float slider_usable_pos_min = (is_horizontal ? frame_bb.Min.x : frame_bb.Min.y) + grab_padding + grab_sz*0.5f;
const float slider_usable_pos_max = (is_horizontal ? frame_bb.Max.x : frame_bb.Max.y) - grab_padding - grab_sz*0.5f;
// For logarithmic sliders that cross over sign boundary we want the exponential increase to be symmetric around 0.0f
float linear_zero_pos = 0.0f; // 0.0->1.0f
if (v_min * v_max < 0.0f)
{
// Different sign
const float linear_dist_min_to_0 = powf(fabsf(0.0f - v_min), 1.0f/power);
const float linear_dist_max_to_0 = powf(fabsf(v_max - 0.0f), 1.0f/power);
linear_zero_pos = linear_dist_min_to_0 / (linear_dist_min_to_0+linear_dist_max_to_0);
}
else
{
// Same sign
linear_zero_pos = v_min < 0.0f ? 1.0f : 0.0f;
}
// Process clicking on the slider
bool value_changed = false;
if (g.ActiveId == id)
{
if (g.IO.MouseDown[0])
{
const float mouse_abs_pos = is_horizontal ? g.IO.MousePos.x : g.IO.MousePos.y;
float normalized_pos = ImClamp((mouse_abs_pos - slider_usable_pos_min) / slider_usable_sz, 0.0f, 1.0f);
if (!is_horizontal)
normalized_pos = 1.0f - normalized_pos;
float new_value;
if (is_non_linear)
{
// Account for logarithmic scale on both sides of the zero
if (normalized_pos < linear_zero_pos)
{
// Negative: rescale to the negative range before powering
float a = 1.0f - (normalized_pos / linear_zero_pos);
a = powf(a, power);
new_value = ImLerp(ImMin(v_max,0.0f), v_min, a);
}
else
{
// Positive: rescale to the positive range before powering
float a;
if (fabsf(linear_zero_pos - 1.0f) > 1.e-6)
a = (normalized_pos - linear_zero_pos) / (1.0f - linear_zero_pos);
else
a = normalized_pos;
a = powf(a, power);
new_value = ImLerp(ImMax(v_min,0.0f), v_max, a);
}
}
else
{
// Linear slider
new_value = ImLerp(v_min, v_max, normalized_pos);
}
// Round past decimal precision
new_value = RoundScalar(new_value, decimal_precision);
if (*v != new_value)
{
*v = new_value;
value_changed = true;
}
}
else
{
SetActiveID(0);
}
}
// Calculate slider grab positioning
float grab_t;
if (is_non_linear)
{
float v_clamped = ImClamp(*v, v_min, v_max);
if (v_clamped < 0.0f)
{
const float f = 1.0f - (v_clamped - v_min) / (ImMin(0.0f,v_max) - v_min);
grab_t = (1.0f - powf(f, 1.0f/power)) * linear_zero_pos;
}
else
{
const float f = (v_clamped - ImMax(0.0f,v_min)) / (v_max - ImMax(0.0f,v_min));
grab_t = linear_zero_pos + powf(f, 1.0f/power) * (1.0f - linear_zero_pos);
}
}
else
{
// Linear slider
grab_t = (ImClamp(*v, v_min, v_max) - v_min) / (v_max - v_min);
}
// Draw
if (!is_horizontal)
grab_t = 1.0f - grab_t;
const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);
ImRect grab_bb;
if (is_horizontal)
grab_bb = ImRect(ImVec2(grab_pos - grab_sz*0.5f, frame_bb.Min.y + grab_padding), ImVec2(grab_pos + grab_sz*0.5f, frame_bb.Max.y - grab_padding));
else
grab_bb = ImRect(ImVec2(frame_bb.Min.x + grab_padding, grab_pos - grab_sz*0.5f), ImVec2(frame_bb.Max.x - grab_padding, grab_pos + grab_sz*0.5f));
window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, GetColorU32(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);
return value_changed;
}
// Use power!=1.0 for logarithmic sliders.
// Adjust display_format to decorate the value with a prefix or a suffix.
// "%.3f" 1.234
// "%5.2f secs" 01.23 secs
// "Gold: %.0f" Gold: 1
bool ImGui::SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const float w = CalcItemWidth();
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y*2.0f));
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
// NB- we don't call ItemSize() yet because we may turn into a text edit box below
if (!ItemAdd(total_bb, &id))
{
ItemSize(total_bb, style.FramePadding.y);
return false;
}
const bool hovered = IsHovered(frame_bb, id);
if (hovered)
SetHoveredID(id);
if (!display_format)
display_format = "%.3f";
int decimal_precision = ParseFormatPrecision(display_format, 3);
// Tabbing or CTRL-clicking on Slider turns it into an input box
bool start_text_input = false;
const bool tab_focus_requested = FocusableItemRegister(window, g.ActiveId == id);
if (tab_focus_requested || (hovered && g.IO.MouseClicked[0]))
{
SetActiveID(id, window);
FocusWindow(window);
if (tab_focus_requested || g.IO.KeyCtrl)
{
start_text_input = true;
g.ScalarAsInputTextId = 0;
}
}
if (start_text_input || (g.ActiveId == id && g.ScalarAsInputTextId == id))
return InputScalarAsWidgetReplacement(frame_bb, label, ImGuiDataType_Float, v, id, decimal_precision);
ItemSize(total_bb, style.FramePadding.y);
// Actual slider behavior + render grab
const bool value_changed = SliderBehavior(frame_bb, id, v, v_min, v_max, power, decimal_precision);
// Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
char value_buf[64];
const char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImGuiAlign_Center|ImGuiAlign_VCenter);
if (label_size.x > 0.0f)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
return value_changed;
}
bool ImGui::VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* display_format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);
const ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
ItemSize(bb, style.FramePadding.y);
if (!ItemAdd(frame_bb, &id))
return false;
const bool hovered = IsHovered(frame_bb, id);
if (hovered)
SetHoveredID(id);
if (!display_format)
display_format = "%.3f";
int decimal_precision = ParseFormatPrecision(display_format, 3);
if (hovered && g.IO.MouseClicked[0])
{
SetActiveID(id, window);
FocusWindow(window);
}
// Actual slider behavior + render grab
bool value_changed = SliderBehavior(frame_bb, id, v, v_min, v_max, power, decimal_precision, ImGuiSliderFlags_Vertical);
// Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
// For the vertical slider we allow centered text to overlap the frame padding
char value_buf[64];
char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, value_buf, value_buf_end, NULL, ImGuiAlign_Center);
if (label_size.x > 0.0f)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
return value_changed;
}
bool ImGui::SliderAngle(const char* label, float* v_rad, float v_degrees_min, float v_degrees_max)
{
float v_deg = (*v_rad) * 360.0f / (2*IM_PI);
bool value_changed = ImGui::SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, "%.0f deg", 1.0f);
*v_rad = v_deg * (2*IM_PI) / 360.0f;
return value_changed;
}
bool ImGui::SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format)
{
if (!display_format)
display_format = "%.0f";
float v_f = (float)*v;
bool value_changed = ImGui::SliderFloat(label, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
*v = (int)v_f;
return value_changed;
}
bool ImGui::VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format)
{
if (!display_format)
display_format = "%.0f";
float v_f = (float)*v;
bool value_changed = ImGui::VSliderFloat(label, size, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
*v = (int)v_f;
return value_changed;
}
// Add multiple sliders on 1 line for compact edition of multiple components
bool ImGui::SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::SliderFloat("##v", &v[i], v_min, v_max, display_format, power);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format, float power)
{
return SliderFloatN(label, v, 2, v_min, v_max, display_format, power);
}
bool ImGui::SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format, float power)
{
return SliderFloatN(label, v, 3, v_min, v_max, display_format, power);
}
bool ImGui::SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* display_format, float power)
{
return SliderFloatN(label, v, 4, v_min, v_max, display_format, power);
}
bool ImGui::SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::SliderInt("##v", &v[i], v_min, v_max, display_format);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* display_format)
{
return SliderIntN(label, v, 2, v_min, v_max, display_format);
}
bool ImGui::SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* display_format)
{
return SliderIntN(label, v, 3, v_min, v_max, display_format);
}
bool ImGui::SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* display_format)
{
return SliderIntN(label, v, 4, v_min, v_max, display_format);
}
bool ImGui::DragBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_speed, float v_min, float v_max, int decimal_precision, float power)
{
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
// Draw frame
const ImU32 frame_col = GetColorU32(g.ActiveId == id ? ImGuiCol_FrameBgActive : g.HoveredId == id ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
RenderFrame(frame_bb.Min, frame_bb.Max, frame_col, true, style.FrameRounding);
bool value_changed = false;
// Process clicking on the drag
if (g.ActiveId == id)
{
if (g.IO.MouseDown[0])
{
if (g.ActiveIdIsJustActivated)
{
// Lock current value on click
g.DragCurrentValue = *v;
g.DragLastMouseDelta = ImVec2(0.f, 0.f);
}
float v_cur = g.DragCurrentValue;
const ImVec2 mouse_drag_delta = ImGui::GetMouseDragDelta(0, 1.0f);
if (fabsf(mouse_drag_delta.x - g.DragLastMouseDelta.x) > 0.0f)
{
float speed = v_speed;
if (speed == 0.0f && (v_max - v_min) != 0.0f && (v_max - v_min) < FLT_MAX)
speed = (v_max - v_min) * g.DragSpeedDefaultRatio;
if (g.IO.KeyShift && g.DragSpeedScaleFast >= 0.0f)
speed = speed * g.DragSpeedScaleFast;
if (g.IO.KeyAlt && g.DragSpeedScaleSlow >= 0.0f)
speed = speed * g.DragSpeedScaleSlow;
float delta = (mouse_drag_delta.x - g.DragLastMouseDelta.x) * speed;
if (fabsf(power - 1.0f) > 0.001f)
{
// Logarithmic curve on both side of 0.0
float v0_abs = v_cur >= 0.0f ? v_cur : -v_cur;
float v0_sign = v_cur >= 0.0f ? 1.0f : -1.0f;
float v1 = powf(v0_abs, 1.0f / power) + (delta * v0_sign);
float v1_abs = v1 >= 0.0f ? v1 : -v1;
float v1_sign = v1 >= 0.0f ? 1.0f : -1.0f; // Crossed sign line
v_cur = powf(v1_abs, power) * v0_sign * v1_sign; // Reapply sign
}
else
{
v_cur += delta;
}
g.DragLastMouseDelta.x = mouse_drag_delta.x;
// Clamp
if (v_min < v_max)
v_cur = ImClamp(v_cur, v_min, v_max);
g.DragCurrentValue = v_cur;
}
// Round to user desired precision, then apply
v_cur = RoundScalar(v_cur, decimal_precision);
if (*v != v_cur)
{
*v = v_cur;
value_changed = true;
}
}
else
{
SetActiveID(0);
}
}
return value_changed;
}
bool ImGui::DragFloat(const char* label, float* v, float v_speed, float v_min, float v_max, const char* display_format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const float w = CalcItemWidth();
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y*2.0f));
const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
// NB- we don't call ItemSize() yet because we may turn into a text edit box below
if (!ItemAdd(total_bb, &id))
{
ItemSize(total_bb, style.FramePadding.y);
return false;
}
const bool hovered = IsHovered(frame_bb, id);
if (hovered)
SetHoveredID(id);
if (!display_format)
display_format = "%.3f";
int decimal_precision = ParseFormatPrecision(display_format, 3);
// Tabbing or CTRL-clicking on Drag turns it into an input box
bool start_text_input = false;
const bool tab_focus_requested = FocusableItemRegister(window, g.ActiveId == id);
if (tab_focus_requested || (hovered && (g.IO.MouseClicked[0] | g.IO.MouseDoubleClicked[0])))
{
SetActiveID(id, window);
FocusWindow(window);
if (tab_focus_requested || g.IO.KeyCtrl || g.IO.MouseDoubleClicked[0])
{
start_text_input = true;
g.ScalarAsInputTextId = 0;
}
}
if (start_text_input || (g.ActiveId == id && g.ScalarAsInputTextId == id))
return InputScalarAsWidgetReplacement(frame_bb, label, ImGuiDataType_Float, v, id, decimal_precision);
// Actual drag behavior
ItemSize(total_bb, style.FramePadding.y);
const bool value_changed = DragBehavior(frame_bb, id, v, v_speed, v_min, v_max, decimal_precision, power);
// Display value using user-provided display format so user can add prefix/suffix/decorations to the value.
char value_buf[64];
const char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
RenderTextClipped(frame_bb.Min, frame_bb.Max, value_buf, value_buf_end, NULL, ImGuiAlign_Center|ImGuiAlign_VCenter);
if (label_size.x > 0.0f)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label);
return value_changed;
}
bool ImGui::DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::DragFloat("##v", &v[i], v_speed, v_min, v_max, display_format, power);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::DragFloat2(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* display_format, float power)
{
return DragFloatN(label, v, 2, v_speed, v_min, v_max, display_format, power);
}
bool ImGui::DragFloat3(const char* label, float v[3], float v_speed, float v_min, float v_max, const char* display_format, float power)
{
return DragFloatN(label, v, 3, v_speed, v_min, v_max, display_format, power);
}
bool ImGui::DragFloat4(const char* label, float v[4], float v_speed, float v_min, float v_max, const char* display_format, float power)
{
return DragFloatN(label, v, 4, v_speed, v_min, v_max, display_format, power);
}
bool ImGui::DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, const char* display_format, const char* display_format_max, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
ImGui::PushID(label);
ImGui::BeginGroup();
PushMultiItemsWidths(2);
bool value_changed = ImGui::DragFloat("##min", v_current_min, v_speed, (v_min >= v_max) ? -FLT_MAX : v_min, (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max), display_format, power);
ImGui::PopItemWidth();
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
value_changed |= ImGui::DragFloat("##max", v_current_max, v_speed, (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min), (v_min >= v_max) ? FLT_MAX : v_max, display_format_max ? display_format_max : display_format, power);
ImGui::PopItemWidth();
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
ImGui::PopID();
return value_changed;
}
// NB: v_speed is float to allow adjusting the drag speed with more precision
bool ImGui::DragInt(const char* label, int* v, float v_speed, int v_min, int v_max, const char* display_format)
{
if (!display_format)
display_format = "%.0f";
float v_f = (float)*v;
bool value_changed = ImGui::DragFloat(label, &v_f, v_speed, (float)v_min, (float)v_max, display_format);
*v = (int)v_f;
return value_changed;
}
bool ImGui::DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::DragInt("##v", &v[i], v_speed, v_min, v_max, display_format);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::DragInt2(const char* label, int v[2], float v_speed, int v_min, int v_max, const char* display_format)
{
return DragIntN(label, v, 2, v_speed, v_min, v_max, display_format);
}
bool ImGui::DragInt3(const char* label, int v[3], float v_speed, int v_min, int v_max, const char* display_format)
{
return DragIntN(label, v, 3, v_speed, v_min, v_max, display_format);
}
bool ImGui::DragInt4(const char* label, int v[4], float v_speed, int v_min, int v_max, const char* display_format)
{
return DragIntN(label, v, 4, v_speed, v_min, v_max, display_format);
}
bool ImGui::DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, const char* display_format, const char* display_format_max)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
ImGui::PushID(label);
ImGui::BeginGroup();
PushMultiItemsWidths(2);
bool value_changed = ImGui::DragInt("##min", v_current_min, v_speed, (v_min >= v_max) ? IM_INT_MIN : v_min, (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max), display_format);
ImGui::PopItemWidth();
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
value_changed |= ImGui::DragInt("##max", v_current_max, v_speed, (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min), (v_min >= v_max) ? IM_INT_MAX : v_max, display_format_max ? display_format_max : display_format);
ImGui::PopItemWidth();
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
ImGui::PopID();
return value_changed;
}
void ImGui::PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImVec2 label_size = CalcTextSize(label, NULL, true);
if (graph_size.x == 0.0f)
graph_size.x = CalcItemWidth();
if (graph_size.y == 0.0f)
graph_size.y = label_size.y + (style.FramePadding.y * 2);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(graph_size.x, graph_size.y));
const ImRect inner_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, NULL))
return;
// Determine scale from values if not specified
if (scale_min == FLT_MAX || scale_max == FLT_MAX)
{
float v_min = FLT_MAX;
float v_max = -FLT_MAX;
for (int i = 0; i < values_count; i++)
{
const float v = values_getter(data, i);
v_min = ImMin(v_min, v);
v_max = ImMax(v_max, v);
}
if (scale_min == FLT_MAX)
scale_min = v_min;
if (scale_max == FLT_MAX)
scale_max = v_max;
}
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
int res_w = ImMin((int)graph_size.x, values_count) + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
int item_count = values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
// Tooltip on hover
int v_hovered = -1;
if (IsHovered(inner_bb, 0))
{
const float t = ImClamp((g.IO.MousePos.x - inner_bb.Min.x) / (inner_bb.Max.x - inner_bb.Min.x), 0.0f, 0.9999f);
const int v_idx = (int)(t * item_count);
IM_ASSERT(v_idx >= 0 && v_idx < values_count);
const float v0 = values_getter(data, (v_idx + values_offset) % values_count);
const float v1 = values_getter(data, (v_idx + 1 + values_offset) % values_count);
if (plot_type == ImGuiPlotType_Lines)
ImGui::SetTooltip("%d: %8.4g\n%d: %8.4g", v_idx, v0, v_idx+1, v1);
else if (plot_type == ImGuiPlotType_Histogram)
ImGui::SetTooltip("%d: %8.4g", v_idx, v0);
v_hovered = v_idx;
}
const float t_step = 1.0f / (float)res_w;
float v0 = values_getter(data, (0 + values_offset) % values_count);
float t0 = 0.0f;
ImVec2 tp0 = ImVec2( t0, 1.0f - ImSaturate((v0 - scale_min) / (scale_max - scale_min)) ); // Point in the normalized space of our target rectangle
const ImU32 col_base = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLines : ImGuiCol_PlotHistogram);
const ImU32 col_hovered = GetColorU32((plot_type == ImGuiPlotType_Lines) ? ImGuiCol_PlotLinesHovered : ImGuiCol_PlotHistogramHovered);
for (int n = 0; n < res_w; n++)
{
const float t1 = t0 + t_step;
const int v1_idx = (int)(t0 * item_count + 0.5f);
IM_ASSERT(v1_idx >= 0 && v1_idx < values_count);
const float v1 = values_getter(data, (v1_idx + values_offset + 1) % values_count);
const ImVec2 tp1 = ImVec2( t1, 1.0f - ImSaturate((v1 - scale_min) / (scale_max - scale_min)) );
// NB: Draw calls are merged together by the DrawList system. Still, we should render our batch are lower level to save a bit of CPU.
ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);
ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, (plot_type == ImGuiPlotType_Lines) ? tp1 : ImVec2(tp1.x, 1.0f));
if (plot_type == ImGuiPlotType_Lines)
{
window->DrawList->AddLine(pos0, pos1, v_hovered == v1_idx ? col_hovered : col_base);
}
else if (plot_type == ImGuiPlotType_Histogram)
{
if (pos1.x >= pos0.x + 2.0f)
pos1.x -= 1.0f;
window->DrawList->AddRectFilled(pos0, pos1, v_hovered == v1_idx ? col_hovered : col_base);
}
t0 = t1;
tp0 = tp1;
}
// Text overlay
if (overlay_text)
RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, overlay_text, NULL, NULL, ImGuiAlign_Center);
if (label_size.x > 0.0f)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, inner_bb.Min.y), label);
}
struct ImGuiPlotArrayGetterData
{
const float* Values;
int Stride;
ImGuiPlotArrayGetterData(const float* values, int stride) { Values = values; Stride = stride; }
};
static float Plot_ArrayGetter(void* data, int idx)
{
ImGuiPlotArrayGetterData* plot_data = (ImGuiPlotArrayGetterData*)data;
const float v = *(float*)(void*)((unsigned char*)plot_data->Values + (size_t)idx * plot_data->Stride);
return v;
}
void ImGui::PlotLines(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride)
{
ImGuiPlotArrayGetterData data(values, stride);
PlotEx(ImGuiPlotType_Lines, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}
void ImGui::PlotLines(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size)
{
PlotEx(ImGuiPlotType_Lines, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}
void ImGui::PlotHistogram(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride)
{
ImGuiPlotArrayGetterData data(values, stride);
PlotEx(ImGuiPlotType_Histogram, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}
void ImGui::PlotHistogram(const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size)
{
PlotEx(ImGuiPlotType_Histogram, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size);
}
// size_arg (for each axis) < 0.0f: align to end, 0.0f: auto, > 0.0f: specified size
void ImGui::ProgressBar(float fraction, const ImVec2& size_arg, const char* overlay)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
ImVec2 pos = window->DC.CursorPos;
ImRect bb(pos, pos + CalcItemSize(size_arg, CalcItemWidth(), g.FontSize + style.FramePadding.y*2.0f));
ItemSize(bb, style.FramePadding.y);
if (!ItemAdd(bb, NULL))
return;
// Render
fraction = ImSaturate(fraction);
RenderFrame(bb.Min, bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
bb.Reduce(ImVec2(window->BorderSize, window->BorderSize));
const ImVec2 fill_br = ImVec2(ImLerp(bb.Min.x, bb.Max.x, fraction), bb.Max.y);
RenderFrame(bb.Min, fill_br, GetColorU32(ImGuiCol_PlotHistogram), false, style.FrameRounding);
// Default displaying the fraction as percentage string, but user can override it
char overlay_buf[32];
if (!overlay)
{
ImFormatString(overlay_buf, IM_ARRAYSIZE(overlay_buf), "%.0f%%", fraction*100+0.01f);
overlay = overlay_buf;
}
ImVec2 overlay_size = CalcTextSize(overlay, NULL);
if (overlay_size.x > 0.0f)
RenderTextClipped(ImVec2(ImClamp(fill_br.x + style.ItemSpacing.x, bb.Min.x, bb.Max.x - overlay_size.x - style.ItemInnerSpacing.x), bb.Min.y), bb.Max, overlay, NULL, &overlay_size, ImGuiAlign_Left|ImGuiAlign_VCenter, &bb.Min, &bb.Max);
}
bool ImGui::Checkbox(const char* label, bool* v)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(label_size.y + style.FramePadding.y*2, label_size.y + style.FramePadding.y*2));
ItemSize(check_bb, style.FramePadding.y);
ImRect total_bb = check_bb;
if (label_size.x > 0)
SameLine(0, style.ItemInnerSpacing.x);
const ImRect text_bb(window->DC.CursorPos + ImVec2(0,style.FramePadding.y), window->DC.CursorPos + ImVec2(0,style.FramePadding.y) + label_size);
if (label_size.x > 0)
{
ItemSize(ImVec2(text_bb.GetWidth(), check_bb.GetHeight()), style.FramePadding.y);
total_bb = ImRect(ImMin(check_bb.Min, text_bb.Min), ImMax(check_bb.Max, text_bb.Max));
}
if (!ItemAdd(total_bb, &id))
return false;
bool hovered, held;
bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);
if (pressed)
*v = !(*v);
RenderFrame(check_bb.Min, check_bb.Max, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), true, style.FrameRounding);
if (*v)
{
const float check_sz = ImMin(check_bb.GetWidth(), check_bb.GetHeight());
const float pad = ImMax(1.0f, (float)(int)(check_sz / 6.0f));
window->DrawList->AddRectFilled(check_bb.Min+ImVec2(pad,pad), check_bb.Max-ImVec2(pad,pad), GetColorU32(ImGuiCol_CheckMark), style.FrameRounding);
}
if (g.LogEnabled)
LogRenderedText(text_bb.GetTL(), *v ? "[x]" : "[ ]");
if (label_size.x > 0.0f)
RenderText(text_bb.GetTL(), label);
return pressed;
}
bool ImGui::CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value)
{
bool v = ((*flags & flags_value) == flags_value);
bool pressed = ImGui::Checkbox(label, &v);
if (pressed)
{
if (v)
*flags |= flags_value;
else
*flags &= ~flags_value;
}
return pressed;
}
bool ImGui::RadioButton(const char* label, bool active)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(label_size.y + style.FramePadding.y*2-1, label_size.y + style.FramePadding.y*2-1));
ItemSize(check_bb, style.FramePadding.y);
ImRect total_bb = check_bb;
if (label_size.x > 0)
SameLine(0, style.ItemInnerSpacing.x);
const ImRect text_bb(window->DC.CursorPos + ImVec2(0, style.FramePadding.y), window->DC.CursorPos + ImVec2(0, style.FramePadding.y) + label_size);
if (label_size.x > 0)
{
ItemSize(ImVec2(text_bb.GetWidth(), check_bb.GetHeight()), style.FramePadding.y);
total_bb.Add(text_bb);
}
if (!ItemAdd(total_bb, &id))
return false;
ImVec2 center = check_bb.GetCenter();
center.x = (float)(int)center.x + 0.5f;
center.y = (float)(int)center.y + 0.5f;
const float radius = check_bb.GetHeight() * 0.5f;
bool hovered, held;
bool pressed = ButtonBehavior(total_bb, id, &hovered, &held);
window->DrawList->AddCircleFilled(center, radius, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), 16);
if (active)
{
const float check_sz = ImMin(check_bb.GetWidth(), check_bb.GetHeight());
const float pad = ImMax(1.0f, (float)(int)(check_sz / 6.0f));
window->DrawList->AddCircleFilled(center, radius-pad, GetColorU32(ImGuiCol_CheckMark), 16);
}
if (window->Flags & ImGuiWindowFlags_ShowBorders)
{
window->DrawList->AddCircle(center+ImVec2(1,1), radius, GetColorU32(ImGuiCol_BorderShadow), 16);
window->DrawList->AddCircle(center, radius, GetColorU32(ImGuiCol_Border), 16);
}
if (g.LogEnabled)
LogRenderedText(text_bb.GetTL(), active ? "(x)" : "( )");
if (label_size.x > 0.0f)
RenderText(text_bb.GetTL(), label);
return pressed;
}
bool ImGui::RadioButton(const char* label, int* v, int v_button)
{
const bool pressed = ImGui::RadioButton(label, *v == v_button);
if (pressed)
{
*v = v_button;
}
return pressed;
}
static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end)
{
int line_count = 0;
const char* s = text_begin;
while (char c = *s++) // We are only matching for \n so we can ignore UTF-8 decoding
if (c == '\n')
line_count++;
s--;
if (s[0] != '\n' && s[0] != '\r')
line_count++;
*out_text_end = s;
return line_count;
}
static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining, ImVec2* out_offset, bool stop_on_new_line)
{
ImFont* font = GImGui->Font;
const float line_height = GImGui->FontSize;
const float scale = line_height / font->FontSize;
ImVec2 text_size = ImVec2(0,0);
float line_width = 0.0f;
const ImWchar* s = text_begin;
while (s < text_end)
{
unsigned int c = (unsigned int)(*s++);
if (c == '\n')
{
text_size.x = ImMax(text_size.x, line_width);
text_size.y += line_height;
line_width = 0.0f;
if (stop_on_new_line)
break;
continue;
}
if (c == '\r')
continue;
const float char_width = font->GetCharAdvance((unsigned short)c) * scale;
line_width += char_width;
}
if (text_size.x < line_width)
text_size.x = line_width;
if (out_offset)
*out_offset = ImVec2(line_width, text_size.y + line_height); // offset allow for the possibility of sitting after a trailing \n
if (line_width > 0 || text_size.y == 0.0f) // whereas size.y will ignore the trailing \n
text_size.y += line_height;
if (remaining)
*remaining = s;
return text_size;
}
// Wrapper for stb_textedit.h to edit text (our wrapper is for: statically sized buffer, single-line, wchar characters. InputText converts between UTF-8 and wchar)
namespace ImGuiStb
{
static int STB_TEXTEDIT_STRINGLEN(const STB_TEXTEDIT_STRING* obj) { return obj->CurLenW; }
static ImWchar STB_TEXTEDIT_GETCHAR(const STB_TEXTEDIT_STRING* obj, int idx) { return obj->Text[idx]; }
static float STB_TEXTEDIT_GETWIDTH(STB_TEXTEDIT_STRING* obj, int line_start_idx, int char_idx) { ImWchar c = obj->Text[line_start_idx+char_idx]; if (c == '\n') return STB_TEXTEDIT_GETWIDTH_NEWLINE; return GImGui->Font->GetCharAdvance(c) * (GImGui->FontSize / GImGui->Font->FontSize); }
static int STB_TEXTEDIT_KEYTOTEXT(int key) { return key >= 0x10000 ? 0 : key; }
static ImWchar STB_TEXTEDIT_NEWLINE = '\n';
static void STB_TEXTEDIT_LAYOUTROW(StbTexteditRow* r, STB_TEXTEDIT_STRING* obj, int line_start_idx)
{
const ImWchar* text = obj->Text.Data;
const ImWchar* text_remaining = NULL;
const ImVec2 size = InputTextCalcTextSizeW(text + line_start_idx, text + obj->CurLenW, &text_remaining, NULL, true);
r->x0 = 0.0f;
r->x1 = size.x;
r->baseline_y_delta = size.y;
r->ymin = 0.0f;
r->ymax = size.y;
r->num_chars = (int)(text_remaining - (text + line_start_idx));
}
static bool is_separator(unsigned int c) { return ImCharIsSpace(c) || c==',' || c==';' || c=='(' || c==')' || c=='{' || c=='}' || c=='[' || c==']' || c=='|'; }
static int is_word_boundary_from_right(STB_TEXTEDIT_STRING* obj, int idx) { return idx > 0 ? (is_separator( obj->Text[idx-1] ) && !is_separator( obj->Text[idx] ) ) : 1; }
static int STB_TEXTEDIT_MOVEWORDLEFT_IMPL(STB_TEXTEDIT_STRING* obj, int idx) { while (idx >= 0 && !is_word_boundary_from_right(obj, idx)) idx--; return idx < 0 ? 0 : idx; }
#ifdef __APPLE__ // FIXME: Move setting to IO structure
static int is_word_boundary_from_left(STB_TEXTEDIT_STRING* obj, int idx) { return idx > 0 ? (!is_separator( obj->Text[idx-1] ) && is_separator( obj->Text[idx] ) ) : 1; }
static int STB_TEXTEDIT_MOVEWORDRIGHT_IMPL(STB_TEXTEDIT_STRING* obj, int idx) { int len = obj->CurLenW; while (idx < len && !is_word_boundary_from_left(obj, idx)) idx++; return idx > len ? len : idx; }
#else
static int STB_TEXTEDIT_MOVEWORDRIGHT_IMPL(STB_TEXTEDIT_STRING* obj, int idx) { int len = obj->CurLenW; while (idx < len && !is_word_boundary_from_right(obj, idx)) idx++; return idx > len ? len : idx; }
#endif
#define STB_TEXTEDIT_MOVEWORDLEFT STB_TEXTEDIT_MOVEWORDLEFT_IMPL // They need to be #define for stb_textedit.h
#define STB_TEXTEDIT_MOVEWORDRIGHT STB_TEXTEDIT_MOVEWORDRIGHT_IMPL
static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
ImWchar* dst = obj->Text.Data + pos;
// We maintain our buffer length in both UTF-8 and wchar formats
obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
obj->CurLenW -= n;
// Offset remaining text
const ImWchar* src = obj->Text.Data + pos + n;
while (ImWchar c = *src++)
*dst++ = c;
*dst = '\0';
}
static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
const int text_len = obj->CurLenW;
if (new_text_len + text_len + 1 > obj->Text.Size)
return false;
const int new_text_len_utf8 = ImTextCountUtf8BytesFromStr(new_text, new_text + new_text_len);
if (new_text_len_utf8 + obj->CurLenA + 1 > obj->BufSizeA)
return false;
ImWchar* text = obj->Text.Data;
if (pos != text_len)
memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos) * sizeof(ImWchar));
memcpy(text + pos, new_text, (size_t)new_text_len * sizeof(ImWchar));
obj->CurLenW += new_text_len;
obj->CurLenA += new_text_len_utf8;
obj->Text[obj->CurLenW] = '\0';
return true;
}
// We don't use an enum so we can build even with conflicting symbols (if another user of stb_textedit.h leak their STB_TEXTEDIT_K_* symbols)
#define STB_TEXTEDIT_K_LEFT 0x10000 // keyboard input to move cursor left
#define STB_TEXTEDIT_K_RIGHT 0x10001 // keyboard input to move cursor right
#define STB_TEXTEDIT_K_UP 0x10002 // keyboard input to move cursor up
#define STB_TEXTEDIT_K_DOWN 0x10003 // keyboard input to move cursor down
#define STB_TEXTEDIT_K_LINESTART 0x10004 // keyboard input to move cursor to start of line
#define STB_TEXTEDIT_K_LINEEND 0x10005 // keyboard input to move cursor to end of line
#define STB_TEXTEDIT_K_TEXTSTART 0x10006 // keyboard input to move cursor to start of text
#define STB_TEXTEDIT_K_TEXTEND 0x10007 // keyboard input to move cursor to end of text
#define STB_TEXTEDIT_K_DELETE 0x10008 // keyboard input to delete selection or character under cursor
#define STB_TEXTEDIT_K_BACKSPACE 0x10009 // keyboard input to delete selection or character left of cursor
#define STB_TEXTEDIT_K_UNDO 0x1000A // keyboard input to perform undo
#define STB_TEXTEDIT_K_REDO 0x1000B // keyboard input to perform redo
#define STB_TEXTEDIT_K_WORDLEFT 0x1000C // keyboard input to move cursor left one word
#define STB_TEXTEDIT_K_WORDRIGHT 0x1000D // keyboard input to move cursor right one word
#define STB_TEXTEDIT_K_SHIFT 0x20000
#define STB_TEXTEDIT_IMPLEMENTATION
#include "stb_textedit.h"
}
void ImGuiTextEditState::OnKeyPressed(int key)
{
stb_textedit_key(this, &StbState, key);
CursorFollow = true;
CursorAnimReset();
}
// Public API to manipulate UTF-8 text
// We expose UTF-8 to the user (unlike the STB_TEXTEDIT_* functions which are manipulating wchar)
// FIXME: The existence of this rarely exercised code path is a bit of a nuisance.
void ImGuiTextEditCallbackData::DeleteChars(int pos, int bytes_count)
{
IM_ASSERT(pos + bytes_count <= BufTextLen);
char* dst = Buf + pos;
const char* src = Buf + pos + bytes_count;
while (char c = *src++)
*dst++ = c;
*dst = '\0';
if (CursorPos + bytes_count >= pos)
CursorPos -= bytes_count;
else if (CursorPos >= pos)
CursorPos = pos;
SelectionStart = SelectionEnd = CursorPos;
BufDirty = true;
BufTextLen -= bytes_count;
}
void ImGuiTextEditCallbackData::InsertChars(int pos, const char* new_text, const char* new_text_end)
{
const int new_text_len = new_text_end ? (int)(new_text_end - new_text) : (int)strlen(new_text);
if (new_text_len + BufTextLen + 1 >= BufSize)
return;
if (BufTextLen != pos)
memmove(Buf + pos + new_text_len, Buf + pos, (size_t)(BufTextLen - pos));
memcpy(Buf + pos, new_text, (size_t)new_text_len * sizeof(char));
Buf[BufTextLen + new_text_len] = '\0';
if (CursorPos >= pos)
CursorPos += new_text_len;
SelectionStart = SelectionEnd = CursorPos;
BufDirty = true;
BufTextLen += new_text_len;
}
// Return false to discard a character.
static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
{
unsigned int c = *p_char;
if (c < 128 && c != ' ' && !isprint((int)(c & 0xFF)))
{
bool pass = false;
pass |= (c == '\n' && (flags & ImGuiInputTextFlags_Multiline));
pass |= (c == '\t' && (flags & ImGuiInputTextFlags_AllowTabInput));
if (!pass)
return false;
}
if (c >= 0xE000 && c <= 0xF8FF) // Filter private Unicode range. I don't imagine anybody would want to input them. GLFW on OSX seems to send private characters for special keys like arrow keys.
return false;
if (flags & (ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase | ImGuiInputTextFlags_CharsNoBlank))
{
if (flags & ImGuiInputTextFlags_CharsDecimal)
if (!(c >= '0' && c <= '9') && (c != '.') && (c != '-') && (c != '+') && (c != '*') && (c != '/'))
return false;
if (flags & ImGuiInputTextFlags_CharsHexadecimal)
if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))
return false;
if (flags & ImGuiInputTextFlags_CharsUppercase)
if (c >= 'a' && c <= 'z')
*p_char = (c += (unsigned int)('A'-'a'));
if (flags & ImGuiInputTextFlags_CharsNoBlank)
if (ImCharIsSpace(c))
return false;
}
if (flags & ImGuiInputTextFlags_CallbackCharFilter)
{
ImGuiTextEditCallbackData callback_data;
memset(&callback_data, 0, sizeof(ImGuiTextEditCallbackData));
callback_data.EventFlag = ImGuiInputTextFlags_CallbackCharFilter;
callback_data.EventChar = (ImWchar)c;
callback_data.Flags = flags;
callback_data.UserData = user_data;
if (callback(&callback_data) != 0)
return false;
*p_char = callback_data.EventChar;
if (!callback_data.EventChar)
return false;
}
return true;
}
// Edit a string of text
// NB: when active, hold on a privately held copy of the text (and apply back to 'buf'). So changing 'buf' while active has no effect.
// FIXME: Rather messy function partly because we are doing UTF8 > u16 > UTF8 conversions on the go to more easily handle stb_textedit calls. Ideally we should stay in UTF-8 all the time. See https://github.com/nothings/stb/issues/188
bool ImGui::InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackHistory) && (flags & ImGuiInputTextFlags_Multiline))); // Can't use both together (they both use up/down keys)
IM_ASSERT(!((flags & ImGuiInputTextFlags_CallbackCompletion) && (flags & ImGuiInputTextFlags_AllowTabInput))); // Can't use both together (they both use tab key)
ImGuiState& g = *GImGui;
const ImGuiIO& io = g.IO;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const bool is_multiline = (flags & ImGuiInputTextFlags_Multiline) != 0;
const bool is_editable = (flags & ImGuiInputTextFlags_ReadOnly) == 0;
const bool is_password = (flags & ImGuiInputTextFlags_Password) != 0;
const ImVec2 label_size = CalcTextSize(label, NULL, true);
ImVec2 size = CalcItemSize(size_arg, CalcItemWidth(), (is_multiline ? ImGui::GetTextLineHeight() * 8.0f : label_size.y) + style.FramePadding.y*2.0f); // Arbitrary default of 8 lines high for multi-line
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + size);
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? (style.ItemInnerSpacing.x + label_size.x) : 0.0f, 0.0f));
ImGuiWindow* draw_window = window;
if (is_multiline)
{
ImGui::BeginGroup();
if (!ImGui::BeginChildFrame(id, frame_bb.GetSize()))
{
ImGui::EndChildFrame();
ImGui::EndGroup();
return false;
}
draw_window = GetCurrentWindow();
size.x -= draw_window->ScrollbarSizes.x;
}
else
{
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, &id))
return false;
}
// Password pushes a temporary font with only a fallback glyph
if (is_password)
{
const ImFont::Glyph* glyph = g.Font->FindGlyph('*');
ImFont* password_font = &g.InputTextPasswordFont;
password_font->FontSize = g.Font->FontSize;
password_font->Scale = g.Font->Scale;
password_font->DisplayOffset = g.Font->DisplayOffset;
password_font->Ascent = g.Font->Ascent;
password_font->Descent = g.Font->Descent;
password_font->ContainerAtlas = g.Font->ContainerAtlas;
password_font->FallbackGlyph = glyph;
password_font->FallbackXAdvance = glyph->XAdvance;
IM_ASSERT(password_font->Glyphs.empty() && password_font->IndexXAdvance.empty() && password_font->IndexLookup.empty());
ImGui::PushFont(password_font);
}
// NB: we are only allowed to access 'edit_state' if we are the active widget.
ImGuiTextEditState& edit_state = g.InputTextState;
const bool is_ctrl_down = io.KeyCtrl;
const bool is_shift_down = io.KeyShift;
const bool is_alt_down = io.KeyAlt;
const bool is_super_down = io.KeySuper;
const bool focus_requested = FocusableItemRegister(window, g.ActiveId == id, (flags & (ImGuiInputTextFlags_CallbackCompletion|ImGuiInputTextFlags_AllowTabInput)) == 0); // Using completion callback disable keyboard tabbing
const bool focus_requested_by_code = focus_requested && (window->FocusIdxAllCounter == window->FocusIdxAllRequestCurrent);
const bool focus_requested_by_tab = focus_requested && !focus_requested_by_code;
const bool hovered = IsHovered(frame_bb, id);
if (hovered)
{
SetHoveredID(id);
g.MouseCursor = ImGuiMouseCursor_TextInput;
}
const bool user_clicked = hovered && io.MouseClicked[0];
const bool user_scrolled = is_multiline && g.ActiveId == 0 && edit_state.Id == id && g.ActiveIdPreviousFrame == draw_window->GetID("#SCROLLY");
bool select_all = (g.ActiveId != id) && (flags & ImGuiInputTextFlags_AutoSelectAll) != 0;
if (focus_requested || user_clicked || user_scrolled)
{
if (g.ActiveId != id)
{
// Start edition
// Take a copy of the initial buffer value (both in original UTF-8 format and converted to wchar)
// From the moment we focused we are ignoring the content of 'buf' (unless we are in read-only mode)
const int prev_len_w = edit_state.CurLenW;
edit_state.Text.resize(buf_size+1); // wchar count <= utf-8 count. we use +1 to make sure that .Data isn't NULL so it doesn't crash.
edit_state.InitialText.resize(buf_size+1); // utf-8. we use +1 to make sure that .Data isn't NULL so it doesn't crash.
ImFormatString(edit_state.InitialText.Data, edit_state.InitialText.Size, "%s", buf);
const char* buf_end = NULL;
edit_state.CurLenW = ImTextStrFromUtf8(edit_state.Text.Data, edit_state.Text.Size, buf, NULL, &buf_end);
edit_state.CurLenA = (int)(buf_end - buf); // We can't get the result from ImFormatString() above because it is not UTF-8 aware. Here we'll cut off malformed UTF-8.
edit_state.CursorAnimReset();
// Preserve cursor position and undo/redo stack if we come back to same widget
// FIXME: We should probably compare the whole buffer to be on the safety side. Comparing buf (utf8) and edit_state.Text (wchar).
const bool recycle_state = (edit_state.Id == id) && (prev_len_w == edit_state.CurLenW);
if (recycle_state)
{
// Recycle existing cursor/selection/undo stack but clamp position
// Note a single mouse click will override the cursor/position immediately by calling stb_textedit_click handler.
edit_state.CursorClamp();
}
else
{
edit_state.Id = id;
edit_state.ScrollX = 0.0f;
stb_textedit_initialize_state(&edit_state.StbState, !is_multiline);
if (!is_multiline && focus_requested_by_code)
select_all = true;
}
if (flags & ImGuiInputTextFlags_AlwaysInsertMode)
edit_state.StbState.insert_mode = true;
if (!is_multiline && (focus_requested_by_tab || (user_clicked && is_ctrl_down)))
select_all = true;
}
SetActiveID(id, window);
FocusWindow(window);
}
else if (io.MouseClicked[0])
{
// Release focus when we click outside
if (g.ActiveId == id)
SetActiveID(0);
}
bool value_changed = false;
bool enter_pressed = false;
if (g.ActiveId == id)
{
if (!is_editable && !g.ActiveIdIsJustActivated)
{
// When read-only we always use the live data passed to the function
edit_state.Text.resize(buf_size+1);
const char* buf_end = NULL;
edit_state.CurLenW = ImTextStrFromUtf8(edit_state.Text.Data, edit_state.Text.Size, buf, NULL, &buf_end);
edit_state.CurLenA = (int)(buf_end - buf);
edit_state.CursorClamp();
}
edit_state.BufSizeA = buf_size;
// Although we are active we don't prevent mouse from hovering other elements unless we are interacting right now with the widget.
// Down the line we should have a cleaner library-wide concept of Selected vs Active.
g.ActiveIdAllowOverlap = !io.MouseDown[0];
// Edit in progress
const float mouse_x = (g.IO.MousePos.x - frame_bb.Min.x - style.FramePadding.x) + edit_state.ScrollX;
const float mouse_y = (is_multiline ? (g.IO.MousePos.y - draw_window->DC.CursorPos.y - style.FramePadding.y) : (g.FontSize*0.5f));
if (select_all || (hovered && !io.DoubleClickSelectsWord && io.MouseDoubleClicked[0]))
{
edit_state.SelectAll();
edit_state.SelectedAllMouseLock = true;
}
else if (hovered && io.DoubleClickSelectsWord && io.MouseDoubleClicked[0])
{
// Select a word only, OS X style (by simulating keystrokes)
edit_state.OnKeyPressed(STB_TEXTEDIT_K_WORDLEFT);
edit_state.OnKeyPressed(STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT);
}
else if (io.MouseClicked[0] && !edit_state.SelectedAllMouseLock)
{
stb_textedit_click(&edit_state, &edit_state.StbState, mouse_x, mouse_y);
edit_state.CursorAnimReset();
}
else if (io.MouseDown[0] && !edit_state.SelectedAllMouseLock && (io.MouseDelta.x != 0.0f || io.MouseDelta.y != 0.0f))
{
stb_textedit_drag(&edit_state, &edit_state.StbState, mouse_x, mouse_y);
edit_state.CursorAnimReset();
edit_state.CursorFollow = true;
}
if (edit_state.SelectedAllMouseLock && !io.MouseDown[0])
edit_state.SelectedAllMouseLock = false;
if (g.IO.InputCharacters[0])
{
// Process text input (before we check for Return because using some IME will effectively send a Return?)
// We ignore CTRL inputs, but need to allow CTRL+ALT as some keyboards (e.g. German) use AltGR - which is Alt+Ctrl - to input certain characters.
if (!(is_ctrl_down && !is_alt_down) && is_editable)
{
for (int n = 0; n < IM_ARRAYSIZE(g.IO.InputCharacters) && g.IO.InputCharacters[n]; n++)
if (unsigned int c = (unsigned int)g.IO.InputCharacters[n])
{
// Insert character if they pass filtering
if (!InputTextFilterCharacter(&c, flags, callback, user_data))
continue;
edit_state.OnKeyPressed((int)c);
}
}
// Consume characters
memset(g.IO.InputCharacters, 0, sizeof(g.IO.InputCharacters));
}
// Handle various key-presses
bool cancel_edit = false;
const int k_mask = (is_shift_down ? STB_TEXTEDIT_K_SHIFT : 0);
const bool is_shortcutkey_only = (io.ShortcutsUseSuperKey ? (is_super_down && !is_alt_down && !is_shift_down && !is_ctrl_down) : (is_ctrl_down && !is_alt_down && !is_shift_down && !is_super_down));
const bool is_wordmove_key_down = (io.WordMovementUsesAltKey ? io.KeyAlt : io.KeyCtrl);
if (IsKeyPressedMap(ImGuiKey_LeftArrow)) { edit_state.OnKeyPressed(is_wordmove_key_down ? STB_TEXTEDIT_K_WORDLEFT | k_mask : STB_TEXTEDIT_K_LEFT | k_mask); }
else if (IsKeyPressedMap(ImGuiKey_RightArrow)) { edit_state.OnKeyPressed(is_wordmove_key_down ? STB_TEXTEDIT_K_WORDRIGHT | k_mask : STB_TEXTEDIT_K_RIGHT | k_mask); }
else if (is_multiline && IsKeyPressedMap(ImGuiKey_UpArrow)) { if (is_ctrl_down) SetWindowScrollY(draw_window, draw_window->Scroll.y - g.FontSize); else edit_state.OnKeyPressed(STB_TEXTEDIT_K_UP | k_mask); }
else if (is_multiline && IsKeyPressedMap(ImGuiKey_DownArrow)) { if (is_ctrl_down) SetWindowScrollY(draw_window, draw_window->Scroll.y + g.FontSize); else edit_state.OnKeyPressed(STB_TEXTEDIT_K_DOWN| k_mask); }
else if (IsKeyPressedMap(ImGuiKey_Home)) { edit_state.OnKeyPressed(is_ctrl_down ? STB_TEXTEDIT_K_TEXTSTART | k_mask : STB_TEXTEDIT_K_LINESTART | k_mask); }
else if (IsKeyPressedMap(ImGuiKey_End)) { edit_state.OnKeyPressed(is_ctrl_down ? STB_TEXTEDIT_K_TEXTEND | k_mask : STB_TEXTEDIT_K_LINEEND | k_mask); }
else if (IsKeyPressedMap(ImGuiKey_Delete) && is_editable) { edit_state.OnKeyPressed(STB_TEXTEDIT_K_DELETE | k_mask); }
else if (IsKeyPressedMap(ImGuiKey_Backspace) && is_editable) { edit_state.OnKeyPressed(STB_TEXTEDIT_K_BACKSPACE | k_mask); }
else if (IsKeyPressedMap(ImGuiKey_Enter))
{
bool ctrl_enter_for_new_line = (flags & ImGuiInputTextFlags_CtrlEnterForNewLine) != 0;
if (!is_multiline || (ctrl_enter_for_new_line && !is_ctrl_down) || (!ctrl_enter_for_new_line && is_ctrl_down))
{
SetActiveID(0);
enter_pressed = true;
}
else if (is_editable)
{
unsigned int c = '\n'; // Insert new line
if (InputTextFilterCharacter(&c, flags, callback, user_data))
edit_state.OnKeyPressed((int)c);
}
}
else if ((flags & ImGuiInputTextFlags_AllowTabInput) && IsKeyPressedMap(ImGuiKey_Tab) && !is_ctrl_down && !is_shift_down && !is_alt_down && is_editable)
{
unsigned int c = '\t'; // Insert TAB
if (InputTextFilterCharacter(&c, flags, callback, user_data))
edit_state.OnKeyPressed((int)c);
}
else if (IsKeyPressedMap(ImGuiKey_Escape)) { SetActiveID(0); cancel_edit = true; }
else if (is_shortcutkey_only && IsKeyPressedMap(ImGuiKey_Z) && is_editable) { edit_state.OnKeyPressed(STB_TEXTEDIT_K_UNDO); edit_state.ClearSelection(); }
else if (is_shortcutkey_only && IsKeyPressedMap(ImGuiKey_Y) && is_editable) { edit_state.OnKeyPressed(STB_TEXTEDIT_K_REDO); edit_state.ClearSelection(); }
else if (is_shortcutkey_only && IsKeyPressedMap(ImGuiKey_A)) { edit_state.SelectAll(); edit_state.CursorFollow = true; }
else if (is_shortcutkey_only && !is_password && ((IsKeyPressedMap(ImGuiKey_X) && is_editable) || IsKeyPressedMap(ImGuiKey_C)) && (!is_multiline || edit_state.HasSelection()))
{
// Cut, Copy
const bool cut = IsKeyPressedMap(ImGuiKey_X);
if (cut && !edit_state.HasSelection())
edit_state.SelectAll();
if (g.IO.SetClipboardTextFn)
{
const int ib = edit_state.HasSelection() ? ImMin(edit_state.StbState.select_start, edit_state.StbState.select_end) : 0;
const int ie = edit_state.HasSelection() ? ImMax(edit_state.StbState.select_start, edit_state.StbState.select_end) : edit_state.CurLenW;
edit_state.TempTextBuffer.resize((ie-ib) * 4 + 1);
ImTextStrToUtf8(edit_state.TempTextBuffer.Data, edit_state.TempTextBuffer.Size, edit_state.Text.Data+ib, edit_state.Text.Data+ie);
g.IO.SetClipboardTextFn(edit_state.TempTextBuffer.Data);
}
if (cut)
{
edit_state.CursorFollow = true;
stb_textedit_cut(&edit_state, &edit_state.StbState);
}
}
else if (is_shortcutkey_only && IsKeyPressedMap(ImGuiKey_V) && is_editable)
{
// Paste
if (g.IO.GetClipboardTextFn)
{
if (const char* clipboard = g.IO.GetClipboardTextFn())
{
// Remove new-line from pasted buffer
const int clipboard_len = (int)strlen(clipboard);
ImWchar* clipboard_filtered = (ImWchar*)ImGui::MemAlloc((clipboard_len+1) * sizeof(ImWchar));
int clipboard_filtered_len = 0;
for (const char* s = clipboard; *s; )
{
unsigned int c;
s += ImTextCharFromUtf8(&c, s, NULL);
if (c == 0)
break;
if (c >= 0x10000 || !InputTextFilterCharacter(&c, flags, callback, user_data))
continue;
clipboard_filtered[clipboard_filtered_len++] = (ImWchar)c;
}
clipboard_filtered[clipboard_filtered_len] = 0;
if (clipboard_filtered_len > 0) // If everything was filtered, ignore the pasting operation
{
stb_textedit_paste(&edit_state, &edit_state.StbState, clipboard_filtered, clipboard_filtered_len);
edit_state.CursorFollow = true;
}
ImGui::MemFree(clipboard_filtered);
}
}
}
if (cancel_edit)
{
// Restore initial value
if (is_editable)
{
ImFormatString(buf, buf_size, "%s", edit_state.InitialText.Data);
value_changed = true;
}
}
else
{
// Apply new value immediately - copy modified buffer back
// Note that as soon as the input box is active, the in-widget value gets priority over any underlying modification of the input buffer
// FIXME: We actually always render 'buf' when calling DrawList->AddText, making the comment above incorrect.
// FIXME-OPT: CPU waste to do this every time the widget is active, should mark dirty state from the stb_textedit callbacks.
if (is_editable)
{
edit_state.TempTextBuffer.resize(edit_state.Text.Size * 4);
ImTextStrToUtf8(edit_state.TempTextBuffer.Data, edit_state.TempTextBuffer.Size, edit_state.Text.Data, NULL);
}
// User callback
if ((flags & (ImGuiInputTextFlags_CallbackCompletion | ImGuiInputTextFlags_CallbackHistory | ImGuiInputTextFlags_CallbackAlways)) != 0)
{
IM_ASSERT(callback != NULL);
// The reason we specify the usage semantic (Completion/History) is that Completion needs to disable keyboard TABBING at the moment.
ImGuiInputTextFlags event_flag = 0;
ImGuiKey event_key = ImGuiKey_COUNT;
if ((flags & ImGuiInputTextFlags_CallbackCompletion) != 0 && IsKeyPressedMap(ImGuiKey_Tab))
{
event_flag = ImGuiInputTextFlags_CallbackCompletion;
event_key = ImGuiKey_Tab;
}
else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_UpArrow))
{
event_flag = ImGuiInputTextFlags_CallbackHistory;
event_key = ImGuiKey_UpArrow;
}
else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_DownArrow))
{
event_flag = ImGuiInputTextFlags_CallbackHistory;
event_key = ImGuiKey_DownArrow;
}
else if (flags & ImGuiInputTextFlags_CallbackAlways)
event_flag = ImGuiInputTextFlags_CallbackAlways;
if (event_flag)
{
ImGuiTextEditCallbackData callback_data;
memset(&callback_data, 0, sizeof(ImGuiTextEditCallbackData));
callback_data.EventFlag = event_flag;
callback_data.Flags = flags;
callback_data.UserData = user_data;
callback_data.ReadOnly = !is_editable;
callback_data.EventKey = event_key;
callback_data.Buf = edit_state.TempTextBuffer.Data;
callback_data.BufTextLen = edit_state.CurLenA;
callback_data.BufSize = edit_state.BufSizeA;
callback_data.BufDirty = false;
// We have to convert from wchar-positions to UTF-8-positions, which can be pretty slow (an incentive to ditch the ImWchar buffer, see https://github.com/nothings/stb/issues/188)
ImWchar* text = edit_state.Text.Data;
const int utf8_cursor_pos = callback_data.CursorPos = ImTextCountUtf8BytesFromStr(text, text + edit_state.StbState.cursor);
const int utf8_selection_start = callback_data.SelectionStart = ImTextCountUtf8BytesFromStr(text, text + edit_state.StbState.select_start);
const int utf8_selection_end = callback_data.SelectionEnd = ImTextCountUtf8BytesFromStr(text, text + edit_state.StbState.select_end);
// Call user code
callback(&callback_data);
// Read back what user may have modified
IM_ASSERT(callback_data.Buf == edit_state.TempTextBuffer.Data); // Invalid to modify those fields
IM_ASSERT(callback_data.BufSize == edit_state.BufSizeA);
IM_ASSERT(callback_data.Flags == flags);
if (callback_data.CursorPos != utf8_cursor_pos) edit_state.StbState.cursor = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.CursorPos);
if (callback_data.SelectionStart != utf8_selection_start) edit_state.StbState.select_start = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.SelectionStart);
if (callback_data.SelectionEnd != utf8_selection_end) edit_state.StbState.select_end = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.SelectionEnd);
if (callback_data.BufDirty)
{
IM_ASSERT(callback_data.BufTextLen == (int)strlen(callback_data.Buf)); // You need to maintain BufTextLen if you change the text!
edit_state.CurLenW = ImTextStrFromUtf8(edit_state.Text.Data, edit_state.Text.Size, callback_data.Buf, NULL);
edit_state.CurLenA = callback_data.BufTextLen; // Assume correct length and valid UTF-8 from user, saves us an extra strlen()
edit_state.CursorAnimReset();
}
}
}
// Copy back to user buffer
if (is_editable && strcmp(edit_state.TempTextBuffer.Data, buf) != 0)
{
ImFormatString(buf, buf_size, "%s", edit_state.TempTextBuffer.Data);
value_changed = true;
}
}
}
if (!is_multiline)
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
// Render
const ImVec4 clip_rect(frame_bb.Min.x, frame_bb.Min.y, frame_bb.Min.x + size.x, frame_bb.Min.y + size.y); // Not using frame_bb.Max because we have adjusted size
ImVec2 render_pos = is_multiline ? draw_window->DC.CursorPos : frame_bb.Min + style.FramePadding;
ImVec2 text_size(0.f, 0.f);
if (g.ActiveId == id || (edit_state.Id == id && is_multiline && g.ActiveId == draw_window->GetID("#SCROLLY")))
{
edit_state.CursorAnim += g.IO.DeltaTime;
// We need to:
// - Display the text (this can be more easily clipped)
// - Handle scrolling, highlight selection, display cursor (those all requires some form of 1d->2d cursor position calculation)
// - Measure text height (for scrollbar)
// We are attempting to do most of that in **one main pass** to minimize the computation cost (non-negligible for large amount of text) + 2nd pass for selection rendering (we could merge them by an extra refactoring effort)
const ImWchar* text_begin = edit_state.Text.Data;
ImVec2 cursor_offset, select_start_offset;
{
// Count lines + find lines numbers straddling 'cursor' and 'select_start' position.
const ImWchar* searches_input_ptr[2];
searches_input_ptr[0] = text_begin + edit_state.StbState.cursor;
searches_input_ptr[1] = NULL;
int searches_remaining = 1;
int searches_result_line_number[2] = { -1, -999 };
if (edit_state.StbState.select_start != edit_state.StbState.select_end)
{
searches_input_ptr[1] = text_begin + ImMin(edit_state.StbState.select_start, edit_state.StbState.select_end);
searches_result_line_number[1] = -1;
searches_remaining++;
}
// Iterate all lines to find our line numbers
// In multi-line mode, we never exit the loop until all lines are counted, so add one extra to the searches_remaining counter.
searches_remaining += is_multiline ? 1 : 0;
int line_count = 0;
for (const ImWchar* s = text_begin; *s != 0; s++)
if (*s == '\n')
{
line_count++;
if (searches_result_line_number[0] == -1 && s >= searches_input_ptr[0]) { searches_result_line_number[0] = line_count; if (--searches_remaining <= 0) break; }
if (searches_result_line_number[1] == -1 && s >= searches_input_ptr[1]) { searches_result_line_number[1] = line_count; if (--searches_remaining <= 0) break; }
}
line_count++;
if (searches_result_line_number[0] == -1) searches_result_line_number[0] = line_count;
if (searches_result_line_number[1] == -1) searches_result_line_number[1] = line_count;
// Calculate 2d position by finding the beginning of the line and measuring distance
cursor_offset.x = InputTextCalcTextSizeW(ImStrbolW(searches_input_ptr[0], text_begin), searches_input_ptr[0]).x;
cursor_offset.y = searches_result_line_number[0] * g.FontSize;
if (searches_result_line_number[1] >= 0)
{
select_start_offset.x = InputTextCalcTextSizeW(ImStrbolW(searches_input_ptr[1], text_begin), searches_input_ptr[1]).x;
select_start_offset.y = searches_result_line_number[1] * g.FontSize;
}
// Calculate text height
if (is_multiline)
text_size = ImVec2(size.x, line_count * g.FontSize);
}
// Scroll
if (edit_state.CursorFollow)
{
// Horizontal scroll in chunks of quarter width
if (!(flags & ImGuiInputTextFlags_NoHorizontalScroll))
{
const float scroll_increment_x = size.x * 0.25f;
if (cursor_offset.x < edit_state.ScrollX)
edit_state.ScrollX = (float)(int)ImMax(0.0f, cursor_offset.x - scroll_increment_x);
else if (cursor_offset.x - size.x >= edit_state.ScrollX)
edit_state.ScrollX = (float)(int)(cursor_offset.x - size.x + scroll_increment_x);
}
else
{
edit_state.ScrollX = 0.0f;
}
// Vertical scroll
if (is_multiline)
{
float scroll_y = draw_window->Scroll.y;
if (cursor_offset.y - g.FontSize < scroll_y)
scroll_y = ImMax(0.0f, cursor_offset.y - g.FontSize);
else if (cursor_offset.y - size.y >= scroll_y)
scroll_y = cursor_offset.y - size.y;
draw_window->DC.CursorPos.y += (draw_window->Scroll.y - scroll_y); // To avoid a frame of lag
draw_window->Scroll.y = scroll_y;
render_pos.y = draw_window->DC.CursorPos.y;
}
}
edit_state.CursorFollow = false;
const ImVec2 render_scroll = ImVec2(edit_state.ScrollX, 0.0f);
// Draw selection
if (edit_state.StbState.select_start != edit_state.StbState.select_end)
{
const ImWchar* text_selected_begin = text_begin + ImMin(edit_state.StbState.select_start, edit_state.StbState.select_end);
const ImWchar* text_selected_end = text_begin + ImMax(edit_state.StbState.select_start, edit_state.StbState.select_end);
float bg_offy_up = is_multiline ? 0.0f : -1.0f; // FIXME: those offsets should be part of the style? they don't play so well with multi-line selection.
float bg_offy_dn = is_multiline ? 0.0f : 2.0f;
ImU32 bg_color = GetColorU32(ImGuiCol_TextSelectedBg);
ImVec2 rect_pos = render_pos + select_start_offset - render_scroll;
for (const ImWchar* p = text_selected_begin; p < text_selected_end; )
{
if (rect_pos.y > clip_rect.w + g.FontSize)
break;
if (rect_pos.y < clip_rect.y)
{
while (p < text_selected_end)
if (*p++ == '\n')
break;
}
else
{
ImVec2 rect_size = InputTextCalcTextSizeW(p, text_selected_end, &p, NULL, true);
if (rect_size.x <= 0.0f) rect_size.x = (float)(int)(g.Font->GetCharAdvance((unsigned short)' ') * 0.50f); // So we can see selected empty lines
ImRect rect(rect_pos + ImVec2(0.0f, bg_offy_up - g.FontSize), rect_pos +ImVec2(rect_size.x, bg_offy_dn));
rect.Clip(clip_rect);
if (rect.Overlaps(clip_rect))
draw_window->DrawList->AddRectFilled(rect.Min, rect.Max, bg_color);
}
rect_pos.x = render_pos.x - render_scroll.x;
rect_pos.y += g.FontSize;
}
}
draw_window->DrawList->AddText(g.Font, g.FontSize, render_pos - render_scroll, GetColorU32(ImGuiCol_Text), buf, buf+edit_state.CurLenA, 0.0f, is_multiline ? NULL : &clip_rect);
// Draw blinking cursor
ImVec2 cursor_screen_pos = render_pos + cursor_offset - render_scroll;
bool cursor_is_visible = (g.InputTextState.CursorAnim <= 0.0f) || fmodf(g.InputTextState.CursorAnim, 1.20f) <= 0.80f;
if (cursor_is_visible)
draw_window->DrawList->AddLine(cursor_screen_pos + ImVec2(0.0f,-g.FontSize+0.5f), cursor_screen_pos + ImVec2(0.0f,-1.5f), GetColorU32(ImGuiCol_Text));
// Notify OS of text input position for advanced IME (-1 x offset so that Windows IME can cover our cursor. Bit of an extra nicety.)
if (is_editable)
g.OsImePosRequest = ImVec2(cursor_screen_pos.x - 1, cursor_screen_pos.y - g.FontSize);
}
else
{
// Render text only
const char* buf_end = NULL;
if (is_multiline)
text_size = ImVec2(size.x, InputTextCalcTextLenAndLineCount(buf, &buf_end) * g.FontSize); // We don't need width
draw_window->DrawList->AddText(g.Font, g.FontSize, render_pos, GetColorU32(ImGuiCol_Text), buf, buf_end, 0.0f, is_multiline ? NULL : &clip_rect);
}
if (is_multiline)
{
ImGui::Dummy(text_size + ImVec2(0.0f, g.FontSize)); // Always add room to scroll an extra line
ImGui::EndChildFrame();
ImGui::EndGroup();
}
if (is_password)
ImGui::PopFont();
// Log as text
if (g.LogEnabled && !is_password)
LogRenderedText(render_pos, buf, NULL);
if (label_size.x > 0)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
if ((flags & ImGuiInputTextFlags_EnterReturnsTrue) != 0)
return enter_pressed;
else
return value_changed;
}
bool ImGui::InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
{
IM_ASSERT(!(flags & ImGuiInputTextFlags_Multiline)); // call InputTextMultiline()
bool ret = InputTextEx(label, buf, (int)buf_size, ImVec2(0,0), flags, callback, user_data);
return ret;
}
bool ImGui::InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
{
bool ret = InputTextEx(label, buf, (int)buf_size, size, flags | ImGuiInputTextFlags_Multiline, callback, user_data);
return ret;
}
// NB: scalar_format here must be a simple "%xx" format string with no prefix/suffix (unlike the Drag/Slider functions "display_format" argument)
bool ImGui::InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* scalar_format, ImGuiInputTextFlags extra_flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImVec2 label_size = CalcTextSize(label, NULL, true);
ImGui::BeginGroup();
ImGui::PushID(label);
const ImVec2 button_sz = ImVec2(g.FontSize, g.FontSize) + style.FramePadding*2.0f;
if (step_ptr)
ImGui::PushItemWidth(ImMax(1.0f, CalcItemWidth() - (button_sz.x + style.ItemInnerSpacing.x)*2));
char buf[64];
DataTypeFormatString(data_type, data_ptr, scalar_format, buf, IM_ARRAYSIZE(buf));
bool value_changed = false;
if (!(extra_flags & ImGuiInputTextFlags_CharsHexadecimal))
extra_flags |= ImGuiInputTextFlags_CharsDecimal;
extra_flags |= ImGuiInputTextFlags_AutoSelectAll;
if (ImGui::InputText("", buf, IM_ARRAYSIZE(buf), extra_flags))
value_changed = DataTypeApplyOpFromText(buf, GImGui->InputTextState.InitialText.begin(), data_type, data_ptr, scalar_format);
// Step buttons
if (step_ptr)
{
ImGui::PopItemWidth();
ImGui::SameLine(0, style.ItemInnerSpacing.x);
if (ButtonEx("-", button_sz, ImGuiButtonFlags_Repeat | ImGuiButtonFlags_DontClosePopups))
{
DataTypeApplyOp(data_type, '-', data_ptr, g.IO.KeyCtrl && step_fast_ptr ? step_fast_ptr : step_ptr);
value_changed = true;
}
ImGui::SameLine(0, style.ItemInnerSpacing.x);
if (ButtonEx("+", button_sz, ImGuiButtonFlags_Repeat | ImGuiButtonFlags_DontClosePopups))
{
DataTypeApplyOp(data_type, '+', data_ptr, g.IO.KeyCtrl && step_fast_ptr ? step_fast_ptr : step_ptr);
value_changed = true;
}
}
ImGui::PopID();
if (label_size.x > 0)
{
ImGui::SameLine(0, style.ItemInnerSpacing.x);
RenderText(ImVec2(window->DC.CursorPos.x, window->DC.CursorPos.y + style.FramePadding.y), label);
ItemSize(label_size, style.FramePadding.y);
}
ImGui::EndGroup();
return value_changed;
}
bool ImGui::InputFloat(const char* label, float* v, float step, float step_fast, int decimal_precision, ImGuiInputTextFlags extra_flags)
{
char display_format[16];
if (decimal_precision < 0)
strcpy(display_format, "%f"); // Ideally we'd have a minimum decimal precision of 1 to visually denote that this is a float, while hiding non-significant digits? %f doesn't have a minimum of 1
else
ImFormatString(display_format, 16, "%%.%df", decimal_precision);
return InputScalarEx(label, ImGuiDataType_Float, (void*)v, (void*)(step>0.0f ? &step : NULL), (void*)(step_fast>0.0f ? &step_fast : NULL), display_format, extra_flags);
}
bool ImGui::InputInt(const char* label, int* v, int step, int step_fast, ImGuiInputTextFlags extra_flags)
{
// Hexadecimal input provided as a convenience but the flag name is awkward. Typically you'd use InputText() to parse your own data, if you want to handle prefixes.
const char* scalar_format = (extra_flags & ImGuiInputTextFlags_CharsHexadecimal) ? "%08X" : "%d";
return InputScalarEx(label, ImGuiDataType_Int, (void*)v, (void*)(step>0.0f ? &step : NULL), (void*)(step_fast>0.0f ? &step_fast : NULL), scalar_format, extra_flags);
}
bool ImGui::InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::InputFloat("##v", &v[i], 0, 0, decimal_precision, extra_flags);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
window->DC.CurrentLineTextBaseOffset = ImMax(window->DC.CurrentLineTextBaseOffset, g.Style.FramePadding.y);
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::InputFloat2(const char* label, float v[2], int decimal_precision, ImGuiInputTextFlags extra_flags)
{
return InputFloatN(label, v, 2, decimal_precision, extra_flags);
}
bool ImGui::InputFloat3(const char* label, float v[3], int decimal_precision, ImGuiInputTextFlags extra_flags)
{
return InputFloatN(label, v, 3, decimal_precision, extra_flags);
}
bool ImGui::InputFloat4(const char* label, float v[4], int decimal_precision, ImGuiInputTextFlags extra_flags)
{
return InputFloatN(label, v, 4, decimal_precision, extra_flags);
}
bool ImGui::InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
PushMultiItemsWidths(components);
for (int i = 0; i < components; i++)
{
ImGui::PushID(i);
value_changed |= ImGui::InputInt("##v", &v[i], 0, 0, extra_flags);
ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
ImGui::PopID();
ImGui::PopItemWidth();
}
ImGui::PopID();
window->DC.CurrentLineTextBaseOffset = ImMax(window->DC.CurrentLineTextBaseOffset, g.Style.FramePadding.y);
ImGui::TextUnformatted(label, FindRenderedTextEnd(label));
ImGui::EndGroup();
return value_changed;
}
bool ImGui::InputInt2(const char* label, int v[2], ImGuiInputTextFlags extra_flags)
{
return InputIntN(label, v, 2, extra_flags);
}
bool ImGui::InputInt3(const char* label, int v[3], ImGuiInputTextFlags extra_flags)
{
return InputIntN(label, v, 3, extra_flags);
}
bool ImGui::InputInt4(const char* label, int v[4], ImGuiInputTextFlags extra_flags)
{
return InputIntN(label, v, 4, extra_flags);
}
static bool Items_ArrayGetter(void* data, int idx, const char** out_text)
{
const char** items = (const char**)data;
if (out_text)
*out_text = items[idx];
return true;
}
static bool Items_SingleStringGetter(void* data, int idx, const char** out_text)
{
// FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited.
const char* items_separated_by_zeros = (const char*)data;
int items_count = 0;
const char* p = items_separated_by_zeros;
while (*p)
{
if (idx == items_count)
break;
p += strlen(p) + 1;
items_count++;
}
if (!*p)
return false;
if (out_text)
*out_text = p;
return true;
}
// Combo box helper allowing to pass an array of strings.
bool ImGui::Combo(const char* label, int* current_item, const char** items, int items_count, int height_in_items)
{
const bool value_changed = Combo(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_in_items);
return value_changed;
}
// Combo box helper allowing to pass all items in a single string.
bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items)
{
int items_count = 0;
const char* p = items_separated_by_zeros; // FIXME-OPT: Avoid computing this, or at least only when combo is open
while (*p)
{
p += strlen(p) + 1;
items_count++;
}
bool value_changed = Combo(label, current_item, Items_SingleStringGetter, (void*)items_separated_by_zeros, items_count, height_in_items);
return value_changed;
}
// Combo box function.
bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const float w = CalcItemWidth();
const ImVec2 label_size = CalcTextSize(label, NULL, true);
const ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y*2.0f));
const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, &id))
return false;
const float arrow_size = (g.FontSize + style.FramePadding.x * 2.0f);
const bool hovered = IsHovered(frame_bb, id);
bool popup_opened = IsPopupOpen(id);
bool popup_opened_now = false;
const ImRect value_bb(frame_bb.Min, frame_bb.Max - ImVec2(arrow_size, 0.0f));
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
RenderFrame(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y), frame_bb.Max, GetColorU32(popup_opened || hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button), true, style.FrameRounding); // FIXME-ROUNDING
RenderCollapseTriangle(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y) + style.FramePadding, true);
if (*current_item >= 0 && *current_item < items_count)
{
const char* item_text;
if (items_getter(data, *current_item, &item_text))
RenderTextClipped(frame_bb.Min + style.FramePadding, value_bb.Max, item_text, NULL, NULL);
}
if (label_size.x > 0)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
if (hovered)
{
SetHoveredID(id);
if (g.IO.MouseClicked[0])
{
SetActiveID(0);
if (IsPopupOpen(id))
{
ClosePopup(id);
}
else
{
FocusWindow(window);
OpenPopup(label);
popup_opened = popup_opened_now = true;
}
}
}
bool value_changed = false;
if (IsPopupOpen(id))
{
// Size default to hold ~7 items
if (height_in_items < 0)
height_in_items = 7;
float popup_height = (label_size.y + style.ItemSpacing.y) * ImMin(items_count, height_in_items) + (style.FramePadding.y * 3);
float popup_y1 = frame_bb.Max.y;
float popup_y2 = ImClamp(popup_y1 + popup_height, popup_y1, g.IO.DisplaySize.y - style.DisplaySafeAreaPadding.y);
if ((popup_y2 - popup_y1) < ImMin(popup_height, frame_bb.Min.y - style.DisplaySafeAreaPadding.y))
{
// Position our combo ABOVE because there's more space to fit! (FIXME: Handle in Begin() or use a shared helper. We have similar code in Begin() for popup placement)
popup_y1 = ImClamp(frame_bb.Min.y - popup_height, style.DisplaySafeAreaPadding.y, frame_bb.Min.y);
popup_y2 = frame_bb.Min.y;
}
ImRect popup_rect(ImVec2(frame_bb.Min.x, popup_y1), ImVec2(frame_bb.Max.x, popup_y2));
ImGui::SetNextWindowPos(popup_rect.Min);
ImGui::SetNextWindowSize(popup_rect.GetSize());
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
const ImGuiWindowFlags flags = ImGuiWindowFlags_ComboBox | ((window->Flags & ImGuiWindowFlags_ShowBorders) ? ImGuiWindowFlags_ShowBorders : 0);
if (BeginPopupEx(label, flags))
{
// Display items
ImGui::Spacing();
for (int i = 0; i < items_count; i++)
{
ImGui::PushID((void*)(intptr_t)i);
const bool item_selected = (i == *current_item);
const char* item_text;
if (!items_getter(data, i, &item_text))
item_text = "*Unknown item*";
if (ImGui::Selectable(item_text, item_selected))
{
SetActiveID(0);
value_changed = true;
*current_item = i;
}
if (item_selected && popup_opened_now)
ImGui::SetScrollHere();
ImGui::PopID();
}
ImGui::EndPopup();
}
ImGui::PopStyleVar();
}
return value_changed;
}
// Tip: pass an empty label (e.g. "##dummy") then you can use the space to draw other text or image.
// But you need to make sure the ID is unique, e.g. enclose calls in PushID/PopID.
bool ImGui::Selectable(const char* label, bool selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
if ((flags & ImGuiSelectableFlags_SpanAllColumns) && window->DC.ColumnsCount > 1)
PopClipRect();
ImGuiID id = window->GetID(label);
ImVec2 label_size = CalcTextSize(label, NULL, true);
ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);
ImVec2 pos = window->DC.CursorPos;
pos.y += window->DC.CurrentLineTextBaseOffset;
ImRect bb(pos, pos + size);
ItemSize(bb);
// Fill horizontal space.
ImVec2 window_padding = window->WindowPadding;
float max_x = (flags & ImGuiSelectableFlags_SpanAllColumns) ? ImGui::GetWindowContentRegionMax().x : ImGui::GetContentRegionMax().x;
float w_draw = ImMax(label_size.x, window->Pos.x + max_x - window_padding.x - window->DC.CursorPos.x);
ImVec2 size_draw((size_arg.x != 0 && !(flags & ImGuiSelectableFlags_DrawFillAvailWidth)) ? size_arg.x : w_draw, size_arg.y != 0.0f ? size_arg.y : size.y);
ImRect bb_with_spacing(pos, pos + size_draw);
if (size_arg.x == 0.0f || (flags & ImGuiSelectableFlags_DrawFillAvailWidth))
bb_with_spacing.Max.x += window_padding.x;
// Selectables are tightly packed together, we extend the box to cover spacing between selectable.
float spacing_L = (float)(int)(style.ItemSpacing.x * 0.5f);
float spacing_U = (float)(int)(style.ItemSpacing.y * 0.5f);
float spacing_R = style.ItemSpacing.x - spacing_L;
float spacing_D = style.ItemSpacing.y - spacing_U;
bb_with_spacing.Min.x -= spacing_L;
bb_with_spacing.Min.y -= spacing_U;
bb_with_spacing.Max.x += spacing_R;
bb_with_spacing.Max.y += spacing_D;
if (!ItemAdd(bb_with_spacing, &id))
{
if ((flags & ImGuiSelectableFlags_SpanAllColumns) && window->DC.ColumnsCount > 1)
PushColumnClipRect();
return false;
}
ImGuiButtonFlags button_flags = 0;
if (flags & ImGuiSelectableFlags_Menu) button_flags |= ImGuiButtonFlags_PressedOnClick;
if (flags & ImGuiSelectableFlags_MenuItem) button_flags |= ImGuiButtonFlags_PressedOnClick|ImGuiButtonFlags_PressedOnRelease;
if (flags & ImGuiSelectableFlags_Disabled) button_flags |= ImGuiButtonFlags_Disabled;
if (flags & ImGuiSelectableFlags_AllowDoubleClick) button_flags |= ImGuiButtonFlags_PressedOnDoubleClick;
bool hovered, held;
bool pressed = ButtonBehavior(bb_with_spacing, id, &hovered, &held, button_flags);
if (flags & ImGuiSelectableFlags_Disabled)
selected = false;
// Render
if (hovered || selected)
{
const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
RenderFrame(bb_with_spacing.Min, bb_with_spacing.Max, col, false, 0.0f);
}
if ((flags & ImGuiSelectableFlags_SpanAllColumns) && window->DC.ColumnsCount > 1)
{
PushColumnClipRect();
bb_with_spacing.Max.x -= (ImGui::GetContentRegionMax().x - max_x);
}
if (flags & ImGuiSelectableFlags_Disabled) ImGui::PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
RenderTextClipped(bb.Min, bb_with_spacing.Max, label, NULL, &label_size);
if (flags & ImGuiSelectableFlags_Disabled) ImGui::PopStyleColor();
// Automatically close popups
if (pressed && !(flags & ImGuiSelectableFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))
ImGui::CloseCurrentPopup();
return pressed;
}
bool ImGui::Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)
{
if (ImGui::Selectable(label, *p_selected, flags, size_arg))
{
*p_selected = !*p_selected;
return true;
}
return false;
}
// Helper to calculate the size of a listbox and display a label on the right.
// Tip: To have a list filling the entire window width, PushItemWidth(-1) and pass an empty label "##empty"
bool ImGui::ListBoxHeader(const char* label, const ImVec2& size_arg)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
const ImGuiStyle& style = ImGui::GetStyle();
const ImGuiID id = ImGui::GetID(label);
const ImVec2 label_size = CalcTextSize(label, NULL, true);
// Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.
ImVec2 size = CalcItemSize(size_arg, CalcItemWidth(), ImGui::GetTextLineHeightWithSpacing() * 7.4f + style.ItemSpacing.y);
ImVec2 frame_size = ImVec2(size.x, ImMax(size.y, label_size.y));
ImRect frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
ImRect bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
window->DC.LastItemRect = bb;
ImGui::BeginGroup();
if (label_size.x > 0)
RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
ImGui::BeginChildFrame(id, frame_bb.GetSize());
return true;
}
bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items)
{
// Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.
// However we don't add +0.40f if items_count <= height_in_items. It is slightly dodgy, because it means a dynamic list of items will make the widget resize occasionally when it crosses that size.
// I am expecting that someone will come and complain about this behavior in a remote future, then we can advise on a better solution.
if (height_in_items < 0)
height_in_items = ImMin(items_count, 7);
float height_in_items_f = height_in_items < items_count ? (height_in_items + 0.40f) : (height_in_items + 0.00f);
// We include ItemSpacing.y so that a list sized for the exact number of items doesn't make a scrollbar appears. We could also enforce that by passing a flag to BeginChild().
ImVec2 size;
size.x = 0.0f;
size.y = ImGui::GetTextLineHeightWithSpacing() * height_in_items_f + ImGui::GetStyle().ItemSpacing.y;
return ImGui::ListBoxHeader(label, size);
}
void ImGui::ListBoxFooter()
{
ImGuiWindow* parent_window = GetParentWindow();
const ImRect bb = parent_window->DC.LastItemRect;
const ImGuiStyle& style = ImGui::GetStyle();
ImGui::EndChildFrame();
// Redeclare item size so that it includes the label (we have stored the full size in LastItemRect)
// We call SameLine() to restore DC.CurrentLine* data
ImGui::SameLine();
parent_window->DC.CursorPos = bb.Min;
ItemSize(bb, style.FramePadding.y);
ImGui::EndGroup();
}
bool ImGui::ListBox(const char* label, int* current_item, const char** items, int items_count, int height_items)
{
const bool value_changed = ListBox(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_items);
return value_changed;
}
bool ImGui::ListBox(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items)
{
if (!ImGui::ListBoxHeader(label, items_count, height_in_items))
return false;
// Assume all items have even height (= 1 line of text). If you need items of different or variable sizes you can create a custom version of ListBox() in your code without using the clipper.
bool value_changed = false;
ImGuiListClipper clipper(items_count, ImGui::GetTextLineHeightWithSpacing());
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
{
const bool item_selected = (i == *current_item);
const char* item_text;
if (!items_getter(data, i, &item_text))
item_text = "*Unknown item*";
ImGui::PushID(i);
if (ImGui::Selectable(item_text, item_selected))
{
*current_item = i;
value_changed = true;
}
ImGui::PopID();
}
clipper.End();
ImGui::ListBoxFooter();
return value_changed;
}
bool ImGui::MenuItem(const char* label, const char* shortcut, bool selected, bool enabled)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
ImVec2 pos = window->DC.CursorPos;
ImVec2 label_size = CalcTextSize(label, NULL, true);
ImVec2 shortcut_size = shortcut ? CalcTextSize(shortcut, NULL) : ImVec2(0.0f, 0.0f);
float w = window->MenuColumns.DeclColumns(label_size.x, shortcut_size.x, (float)(int)(g.FontSize * 1.20f)); // Feedback for next frame
float extra_w = ImMax(0.0f, ImGui::GetContentRegionAvail().x - w);
bool pressed = ImGui::Selectable(label, false, ImGuiSelectableFlags_MenuItem | ImGuiSelectableFlags_DrawFillAvailWidth | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(w, 0.0f));
if (shortcut_size.x > 0.0f)
{
ImGui::PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
RenderText(pos + ImVec2(window->MenuColumns.Pos[1] + extra_w, 0.0f), shortcut, NULL, false);
ImGui::PopStyleColor();
}
if (selected)
RenderCheckMark(pos + ImVec2(window->MenuColumns.Pos[2] + extra_w + g.FontSize * 0.20f, 0.0f), GetColorU32(ImGuiCol_Text));
return pressed;
}
bool ImGui::MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled)
{
if (ImGui::MenuItem(label, shortcut, p_selected ? *p_selected : false, enabled))
{
if (p_selected)
*p_selected = !*p_selected;
return true;
}
return false;
}
bool ImGui::BeginMainMenuBar()
{
ImGuiState& g = *GImGui;
ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
ImGui::SetNextWindowSize(ImVec2(g.IO.DisplaySize.x, g.FontBaseSize + g.Style.FramePadding.y * 2.0f));
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0,0));
if (!ImGui::Begin("##MainMenuBar", NULL, ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoScrollbar|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_MenuBar)
|| !ImGui::BeginMenuBar())
{
ImGui::End();
ImGui::PopStyleVar(2);
return false;
}
g.CurrentWindow->DC.MenuBarOffsetX += g.Style.DisplaySafeAreaPadding.x;
return true;
}
void ImGui::EndMainMenuBar()
{
ImGui::EndMenuBar();
ImGui::End();
ImGui::PopStyleVar(2);
}
bool ImGui::BeginMenuBar()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
if (!(window->Flags & ImGuiWindowFlags_MenuBar))
return false;
IM_ASSERT(!window->DC.MenuBarAppending);
ImGui::BeginGroup(); // Save position
ImGui::PushID("##menubar");
ImRect rect = window->MenuBarRect();
PushClipRect(ImVec2(rect.Min.x+0.5f, rect.Min.y-0.5f+window->BorderSize), ImVec2(rect.Max.x+0.5f, rect.Max.y-0.5f), false);
window->DC.CursorPos = ImVec2(rect.Min.x + window->DC.MenuBarOffsetX, rect.Min.y);// + g.Style.FramePadding.y);
window->DC.LayoutType = ImGuiLayoutType_Horizontal;
window->DC.MenuBarAppending = true;
ImGui::AlignFirstTextHeightToWidgets();
return true;
}
void ImGui::EndMenuBar()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
IM_ASSERT(window->Flags & ImGuiWindowFlags_MenuBar);
IM_ASSERT(window->DC.MenuBarAppending);
PopClipRect();
ImGui::PopID();
window->DC.MenuBarOffsetX = window->DC.CursorPos.x - window->MenuBarRect().Min.x;
window->DC.GroupStack.back().AdvanceCursor = false;
ImGui::EndGroup();
window->DC.LayoutType = ImGuiLayoutType_Vertical;
window->DC.MenuBarAppending = false;
}
bool ImGui::BeginMenu(const char* label, bool enabled)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
ImVec2 label_size = CalcTextSize(label, NULL, true);
ImGuiWindow* backed_focused_window = g.FocusedWindow;
bool pressed;
bool opened = IsPopupOpen(id);
bool menuset_opened = !(window->Flags & ImGuiWindowFlags_Popup) && (g.OpenedPopupStack.Size > g.CurrentPopupStack.Size && g.OpenedPopupStack[g.CurrentPopupStack.Size].ParentMenuSet == window->GetID("##menus"));
if (menuset_opened)
g.FocusedWindow = window;
ImVec2 popup_pos, pos = window->DC.CursorPos;
if (window->DC.LayoutType == ImGuiLayoutType_Horizontal)
{
popup_pos = ImVec2(pos.x - window->WindowPadding.x, pos.y - style.FramePadding.y + window->MenuBarHeight());
window->DC.CursorPos.x += (float)(int)(style.ItemSpacing.x * 0.5f);
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, style.ItemSpacing * 2.0f);
float w = label_size.x;
pressed = ImGui::Selectable(label, opened, ImGuiSelectableFlags_Menu | ImGuiSelectableFlags_DontClosePopups | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(w, 0.0f));
ImGui::PopStyleVar();
ImGui::SameLine();
window->DC.CursorPos.x += (float)(int)(style.ItemSpacing.x * 0.5f);
}
else
{
popup_pos = ImVec2(pos.x, pos.y - style.WindowPadding.y);
float w = window->MenuColumns.DeclColumns(label_size.x, 0.0f, (float)(int)(g.FontSize * 1.20f)); // Feedback to next frame
float extra_w = ImMax(0.0f, ImGui::GetContentRegionAvail().x - w);
pressed = ImGui::Selectable(label, opened, ImGuiSelectableFlags_Menu | ImGuiSelectableFlags_DontClosePopups | ImGuiSelectableFlags_DrawFillAvailWidth | (!enabled ? ImGuiSelectableFlags_Disabled : 0), ImVec2(w, 0.0f));
if (!enabled) ImGui::PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
RenderCollapseTriangle(pos + ImVec2(window->MenuColumns.Pos[2] + extra_w + g.FontSize * 0.20f, 0.0f), false);
if (!enabled) ImGui::PopStyleColor();
}
bool hovered = enabled && IsHovered(window->DC.LastItemRect, id);
if (menuset_opened)
g.FocusedWindow = backed_focused_window;
bool want_open = false, want_close = false;
if (window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu))
{
// Implement http://bjk5.com/post/44698559168/breaking-down-amazons-mega-dropdown to avoid using timers, so menus feels more reactive.
bool moving_within_opened_triangle = false;
if (g.HoveredWindow == window && g.OpenedPopupStack.Size > g.CurrentPopupStack.Size && g.OpenedPopupStack[g.CurrentPopupStack.Size].ParentWindow == window)
{
if (ImGuiWindow* next_window = g.OpenedPopupStack[g.CurrentPopupStack.Size].Window)
{
ImRect next_window_rect = next_window->Rect();
ImVec2 ta = g.IO.MousePos - g.IO.MouseDelta;
ImVec2 tb = (window->Pos.x < next_window->Pos.x) ? next_window_rect.GetTL() : next_window_rect.GetTR();
ImVec2 tc = (window->Pos.x < next_window->Pos.x) ? next_window_rect.GetBL() : next_window_rect.GetBR();
float extra = ImClamp(fabsf(ta.x - tb.x) * 0.30f, 5.0f, 30.0f); // add a bit of extra slack.
ta.x += (window->Pos.x < next_window->Pos.x) ? -0.5f : +0.5f; // to avoid numerical issues
tb.y = ta.y + ImMax((tb.y - extra) - ta.y, -100.0f); // triangle is maximum 200 high to limit the slope and the bias toward large sub-menus
tc.y = ta.y + ImMin((tc.y + extra) - ta.y, +100.0f);
moving_within_opened_triangle = ImIsPointInTriangle(g.IO.MousePos, ta, tb, tc);
//window->DrawList->PushClipRectFullScreen(); window->DrawList->AddTriangleFilled(ta, tb, tc, moving_within_opened_triangle ? 0x80008000 : 0x80000080); window->DrawList->PopClipRect(); // Debug
}
}
want_close = (opened && !hovered && g.HoveredWindow == window && g.HoveredIdPreviousFrame != 0 && g.HoveredIdPreviousFrame != id && !moving_within_opened_triangle);
want_open = (!opened && hovered && !moving_within_opened_triangle) || (!opened && hovered && pressed);
}
else if (opened && pressed && menuset_opened) // menu-bar: click open menu to close
{
want_close = true;
want_open = opened = false;
}
else if (pressed || (hovered && menuset_opened && !opened)) // menu-bar: first click to open, then hover to open others
want_open = true;
if (want_close && IsPopupOpen(id))
ClosePopupToLevel(GImGui->CurrentPopupStack.Size);
if (!opened && want_open && g.OpenedPopupStack.Size > g.CurrentPopupStack.Size)
{
// Don't recycle same menu level in the same frame, first close the other menu and yield for a frame.
ImGui::OpenPopup(label);
return false;
}
opened |= want_open;
if (want_open)
ImGui::OpenPopup(label);
if (opened)
{
ImGui::SetNextWindowPos(popup_pos, ImGuiSetCond_Always);
ImGuiWindowFlags flags = ImGuiWindowFlags_ShowBorders | ((window->Flags & (ImGuiWindowFlags_Popup|ImGuiWindowFlags_ChildMenu)) ? ImGuiWindowFlags_ChildMenu|ImGuiWindowFlags_ChildWindow : ImGuiWindowFlags_ChildMenu);
opened = BeginPopupEx(label, flags); // opened can be 'false' when the popup is completely clipped (e.g. zero size display)
}
return opened;
}
void ImGui::EndMenu()
{
ImGui::EndPopup();
}
// A little colored square. Return true when clicked.
// FIXME: May want to display/ignore the alpha component in the color display? Yet show it in the tooltip.
bool ImGui::ColorButton(const ImVec4& col, bool small_height, bool outline_border)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID("#colorbutton");
const float square_size = g.FontSize;
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(square_size + style.FramePadding.y*2, square_size + (small_height ? 0 : style.FramePadding.y*2)));
ItemSize(bb, small_height ? 0.0f : style.FramePadding.y);
if (!ItemAdd(bb, &id))
return false;
bool hovered, held;
bool pressed = ButtonBehavior(bb, id, &hovered, &held);
RenderFrame(bb.Min, bb.Max, GetColorU32(col), outline_border, style.FrameRounding);
if (hovered)
ImGui::SetTooltip("Color:\n(%.2f,%.2f,%.2f,%.2f)\n#%02X%02X%02X%02X", col.x, col.y, col.z, col.w, IM_F32_TO_INT8(col.x), IM_F32_TO_INT8(col.y), IM_F32_TO_INT8(col.z), IM_F32_TO_INT8(col.z));
return pressed;
}
bool ImGui::ColorEdit3(const char* label, float col[3])
{
float col4[4];
col4[0] = col[0];
col4[1] = col[1];
col4[2] = col[2];
col4[3] = 1.0f;
const bool value_changed = ImGui::ColorEdit4(label, col4, false);
col[0] = col4[0];
col[1] = col4[1];
col[2] = col4[2];
return value_changed;
}
// Edit colors components (each component in 0.0f..1.0f range
// Use CTRL-Click to input value and TAB to go to next item.
bool ImGui::ColorEdit4(const char* label, float col[4], bool alpha)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiState& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const float w_full = CalcItemWidth();
const float square_sz = (g.FontSize + style.FramePadding.y * 2.0f);
ImGuiColorEditMode edit_mode = window->DC.ColorEditMode;
if (edit_mode == ImGuiColorEditMode_UserSelect || edit_mode == ImGuiColorEditMode_UserSelectShowButton)
edit_mode = g.ColorEditModeStorage.GetInt(id, 0) % 3;
float f[4] = { col[0], col[1], col[2], col[3] };
if (edit_mode == ImGuiColorEditMode_HSV)
ImGui::ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);
int i[4] = { IM_F32_TO_INT8(f[0]), IM_F32_TO_INT8(f[1]), IM_F32_TO_INT8(f[2]), IM_F32_TO_INT8(f[3]) };
int components = alpha ? 4 : 3;
bool value_changed = false;
ImGui::BeginGroup();
ImGui::PushID(label);
const bool hsv = (edit_mode == 1);
switch (edit_mode)
{
case ImGuiColorEditMode_RGB:
case ImGuiColorEditMode_HSV:
{
// RGB/HSV 0..255 Sliders
const float w_items_all = w_full - (square_sz + style.ItemInnerSpacing.x);
const float w_item_one = ImMax(1.0f, (float)(int)((w_items_all - (style.ItemInnerSpacing.x) * (components-1)) / (float)components));
const float w_item_last = ImMax(1.0f, (float)(int)(w_items_all - (w_item_one + style.ItemInnerSpacing.x) * (components-1)));
const bool hide_prefix = (w_item_one <= CalcTextSize("M:999").x);
const char* ids[4] = { "##X", "##Y", "##Z", "##W" };
const char* fmt_table[3][4] =
{
{ "%3.0f", "%3.0f", "%3.0f", "%3.0f" },
{ "R:%3.0f", "G:%3.0f", "B:%3.0f", "A:%3.0f" },
{ "H:%3.0f", "S:%3.0f", "V:%3.0f", "A:%3.0f" }
};
const char** fmt = hide_prefix ? fmt_table[0] : hsv ? fmt_table[2] : fmt_table[1];
ImGui::PushItemWidth(w_item_one);
for (int n = 0; n < components; n++)
{
if (n > 0)
ImGui::SameLine(0, style.ItemInnerSpacing.x);
if (n + 1 == components)
ImGui::PushItemWidth(w_item_last);
value_changed |= ImGui::DragInt(ids[n], &i[n], 1.0f, 0, 255, fmt[n]);
}
ImGui::PopItemWidth();
ImGui::PopItemWidth();
}
break;
case ImGuiColorEditMode_HEX:
{
// RGB Hexadecimal Input
const float w_slider_all = w_full - square_sz;
char buf[64];
if (alpha)
ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X%02X", i[0], i[1], i[2], i[3]);
else
ImFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X", i[0], i[1], i[2]);
ImGui::PushItemWidth(w_slider_all - style.ItemInnerSpacing.x);
if (ImGui::InputText("##Text", buf, IM_ARRAYSIZE(buf), ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_CharsUppercase))
{
value_changed |= true;
char* p = buf;
while (*p == '#' || ImCharIsSpace(*p))
p++;
i[0] = i[1] = i[2] = i[3] = 0;
if (alpha)
sscanf(p, "%02X%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2], (unsigned int*)&i[3]); // Treat at unsigned (%X is unsigned)
else
sscanf(p, "%02X%02X%02X", (unsigned int*)&i[0], (unsigned int*)&i[1], (unsigned int*)&i[2]);
}
ImGui::PopItemWidth();
}
break;
}
ImGui::SameLine(0, style.ItemInnerSpacing.x);
const ImVec4 col_display(col[0], col[1], col[2], 1.0f);
if (ImGui::ColorButton(col_display))
g.ColorEditModeStorage.SetInt(id, (edit_mode + 1) % 3); // Don't set local copy of 'edit_mode' right away!
// Recreate our own tooltip over's ColorButton() one because we want to display correct alpha here
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Color:\n(%.2f,%.2f,%.2f,%.2f)\n#%02X%02X%02X%02X", col[0], col[1], col[2], col[3], IM_F32_TO_INT8(col[0]), IM_F32_TO_INT8(col[1]), IM_F32_TO_INT8(col[2]), IM_F32_TO_INT8(col[3]));
if (window->DC.ColorEditMode == ImGuiColorEditMode_UserSelectShowButton)
{
ImGui::SameLine(0, style.ItemInnerSpacing.x);
const char* button_titles[3] = { "RGB", "HSV", "HEX" };
if (ButtonEx(button_titles[edit_mode], ImVec2(0,0), ImGuiButtonFlags_DontClosePopups))
g.ColorEditModeStorage.SetInt(id, (edit_mode + 1) % 3); // Don't set local copy of 'edit_mode' right away!
}
const char* label_display_end = FindRenderedTextEnd(label);
if (label != label_display_end)
{
ImGui::SameLine(0, (window->DC.ColorEditMode == ImGuiColorEditMode_UserSelectShowButton) ? -1.0f : style.ItemInnerSpacing.x);
ImGui::TextUnformatted(label, label_display_end);
}
// Convert back
for (int n = 0; n < 4; n++)
f[n] = i[n] / 255.0f;
if (edit_mode == 1)
ImGui::ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);
if (value_changed)
{
col[0] = f[0];
col[1] = f[1];
col[2] = f[2];
if (alpha)
col[3] = f[3];
}
ImGui::PopID();
ImGui::EndGroup();
return value_changed;
}
void ImGui::ColorEditMode(ImGuiColorEditMode mode)
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.ColorEditMode = mode;
}
// Horizontal separating line.
void ImGui::Separator()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
if (window->DC.ColumnsCount > 1)
PopClipRect();
float x1 = window->Pos.x;
float x2 = window->Pos.x + window->Size.x;
if (!window->DC.GroupStack.empty())
x1 += window->DC.IndentX;
const ImRect bb(ImVec2(x1, window->DC.CursorPos.y), ImVec2(x2, window->DC.CursorPos.y));
ItemSize(ImVec2(0.0f, 0.0f)); // NB: we don't provide our width so that it doesn't get feed back into AutoFit // FIXME: Height should be 1.0f not 0.0f ?
if (!ItemAdd(bb, NULL))
{
if (window->DC.ColumnsCount > 1)
PushColumnClipRect();
return;
}
window->DrawList->AddLine(bb.Min, bb.Max, GetColorU32(ImGuiCol_Border));
ImGuiState& g = *GImGui;
if (g.LogEnabled)
ImGui::LogText(IM_NEWLINE "--------------------------------");
if (window->DC.ColumnsCount > 1)
{
PushColumnClipRect();
window->DC.ColumnsCellMinY = window->DC.CursorPos.y;
}
}
void ImGui::Spacing()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ItemSize(ImVec2(0,0));
}
void ImGui::Dummy(const ImVec2& size)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
ItemSize(bb);
ItemAdd(bb, NULL);
}
bool ImGui::IsRectVisible(const ImVec2& size)
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->ClipRect.Overlaps(ImRect(window->DC.CursorPos, window->DC.CursorPos + size));
}
void ImGui::BeginGroup()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.GroupStack.resize(window->DC.GroupStack.Size + 1);
ImGuiGroupData& group_data = window->DC.GroupStack.back();
group_data.BackupCursorPos = window->DC.CursorPos;
group_data.BackupCursorMaxPos = window->DC.CursorMaxPos;
group_data.BackupIndentX = window->DC.IndentX;
group_data.BackupCurrentLineHeight = window->DC.CurrentLineHeight;
group_data.BackupCurrentLineTextBaseOffset = window->DC.CurrentLineTextBaseOffset;
group_data.BackupLogLinePosY = window->DC.LogLinePosY;
group_data.AdvanceCursor = true;
window->DC.IndentX = window->DC.CursorPos.x - window->Pos.x;
window->DC.CursorMaxPos = window->DC.CursorPos;
window->DC.CurrentLineHeight = 0.0f;
window->DC.LogLinePosY = window->DC.CursorPos.y - 9999.0f;
}
void ImGui::EndGroup()
{
ImGuiWindow* window = GetCurrentWindow();
ImGuiStyle& style = ImGui::GetStyle();
IM_ASSERT(!window->DC.GroupStack.empty()); // Mismatched BeginGroup()/EndGroup() calls
ImGuiGroupData& group_data = window->DC.GroupStack.back();
ImRect group_bb(group_data.BackupCursorPos, window->DC.CursorMaxPos);
group_bb.Max.y -= style.ItemSpacing.y; // Cancel out last vertical spacing because we are adding one ourselves.
group_bb.Max = ImMax(group_bb.Min, group_bb.Max);
window->DC.CursorPos = group_data.BackupCursorPos;
window->DC.CursorMaxPos = ImMax(group_data.BackupCursorMaxPos, window->DC.CursorMaxPos);
window->DC.CurrentLineHeight = group_data.BackupCurrentLineHeight;
window->DC.CurrentLineTextBaseOffset = group_data.BackupCurrentLineTextBaseOffset;
window->DC.IndentX = group_data.BackupIndentX;
window->DC.LogLinePosY = window->DC.CursorPos.y - 9999.0f;
if (group_data.AdvanceCursor)
{
window->DC.CurrentLineTextBaseOffset = ImMax(window->DC.PrevLineTextBaseOffset, group_data.BackupCurrentLineTextBaseOffset); // FIXME: Incorrect, we should grab the base offset from the *first line* of the group but it is hard to obtain now.
ItemSize(group_bb.GetSize(), group_data.BackupCurrentLineTextBaseOffset);
ItemAdd(group_bb, NULL);
}
window->DC.GroupStack.pop_back();
//window->DrawList->AddRect(group_bb.Min, group_bb.Max, 0xFFFF00FF); // Debug
}
// Gets back to previous line and continue with horizontal layout
// pos_x == 0 : follow on previous item
// pos_x != 0 : align to specified column
// spacing_w < 0 : use default spacing if column_x==0, no spacing if column_x!=0
// spacing_w >= 0 : enforce spacing
void ImGui::SameLine(float pos_x, float spacing_w)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
if (pos_x != 0.0f)
{
if (spacing_w < 0.0f) spacing_w = 0.0f;
window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + pos_x + spacing_w;
window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
}
else
{
if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
window->DC.CursorPos.x = window->DC.CursorPosPrevLine.x + spacing_w;
window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
}
window->DC.CurrentLineHeight = window->DC.PrevLineHeight;
window->DC.CurrentLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
}
void ImGui::NextColumn()
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return;
ImGuiState& g = *GImGui;
if (window->DC.ColumnsCount > 1)
{
ImGui::PopItemWidth();
PopClipRect();
window->DC.ColumnsCellMaxY = ImMax(window->DC.ColumnsCellMaxY, window->DC.CursorPos.y);
if (++window->DC.ColumnsCurrent < window->DC.ColumnsCount)
{
// Columns 1+ cancel out IndentX
window->DC.ColumnsOffsetX = ImGui::GetColumnOffset(window->DC.ColumnsCurrent) - window->DC.IndentX + g.Style.ItemSpacing.x;
window->DrawList->ChannelsSetCurrent(window->DC.ColumnsCurrent);
}
else
{
window->DC.ColumnsCurrent = 0;
window->DC.ColumnsOffsetX = 0.0f;
window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY;
window->DrawList->ChannelsSetCurrent(0);
}
window->DC.CursorPos.x = (float)(int)(window->Pos.x + window->DC.IndentX + window->DC.ColumnsOffsetX);
window->DC.CursorPos.y = window->DC.ColumnsCellMinY;
window->DC.CurrentLineHeight = 0.0f;
window->DC.CurrentLineTextBaseOffset = 0.0f;
PushColumnClipRect();
ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f); // FIXME: Move on columns setup
}
}
int ImGui::GetColumnIndex()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.ColumnsCurrent;
}
int ImGui::GetColumnsCount()
{
ImGuiWindow* window = GetCurrentWindowRead();
return window->DC.ColumnsCount;
}
static float GetDraggedColumnOffset(int column_index)
{
// Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
// window creates a feedback loop because we store normalized positions. So while dragging we enforce absolute positioning.
ImGuiState& g = *GImGui;
ImGuiWindow* window = ImGui::GetCurrentWindowRead();
IM_ASSERT(column_index > 0); // We cannot drag column 0. If you get this assert you may have a conflict between the ID of your columns and another widgets.
IM_ASSERT(g.ActiveId == window->DC.ColumnsSetID + ImGuiID(column_index));
float x = g.IO.MousePos.x + g.ActiveClickDeltaToCenter.x - window->Pos.x;
x = ImClamp(x, ImGui::GetColumnOffset(column_index-1)+g.Style.ColumnsMinSpacing, ImGui::GetColumnOffset(column_index+1)-g.Style.ColumnsMinSpacing);
return (float)(int)x;
}
float ImGui::GetColumnOffset(int column_index)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindowRead();
if (column_index < 0)
column_index = window->DC.ColumnsCurrent;
if (g.ActiveId)
{
const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
if (g.ActiveId == column_id)
return GetDraggedColumnOffset(column_index);
}
IM_ASSERT(column_index < window->DC.ColumnsData.Size);
const float t = window->DC.ColumnsData[column_index].OffsetNorm;
const float x_offset = window->DC.ColumnsMinX + t * (window->DC.ColumnsMaxX - window->DC.ColumnsMinX);
return (float)(int)x_offset;
}
void ImGui::SetColumnOffset(int column_index, float offset)
{
ImGuiWindow* window = GetCurrentWindow();
if (column_index < 0)
column_index = window->DC.ColumnsCurrent;
IM_ASSERT(column_index < window->DC.ColumnsData.Size);
const float t = (offset - window->DC.ColumnsMinX) / (window->DC.ColumnsMaxX - window->DC.ColumnsMinX);
window->DC.ColumnsData[column_index].OffsetNorm = t;
const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
window->DC.StateStorage->SetFloat(column_id, t);
}
float ImGui::GetColumnWidth(int column_index)
{
ImGuiWindow* window = GetCurrentWindowRead();
if (column_index < 0)
column_index = window->DC.ColumnsCurrent;
const float w = GetColumnOffset(column_index+1) - GetColumnOffset(column_index);
return w;
}
static void PushColumnClipRect(int column_index)
{
ImGuiWindow* window = ImGui::GetCurrentWindow();
if (column_index < 0)
column_index = window->DC.ColumnsCurrent;
const float x1 = window->Pos.x + ImGui::GetColumnOffset(column_index) - 1;
const float x2 = window->Pos.x + ImGui::GetColumnOffset(column_index+1) - 1;
ImGui::PushClipRect(ImVec2(x1,-FLT_MAX), ImVec2(x2,+FLT_MAX), true);
}
void ImGui::Columns(int columns_count, const char* id, bool border)
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(columns_count >= 1);
if (window->DC.ColumnsCount != 1)
{
if (window->DC.ColumnsCurrent != 0)
ItemSize(ImVec2(0,0)); // Advance to column 0
ImGui::PopItemWidth();
PopClipRect();
window->DrawList->ChannelsMerge();
window->DC.ColumnsCellMaxY = ImMax(window->DC.ColumnsCellMaxY, window->DC.CursorPos.y);
window->DC.CursorPos.y = window->DC.ColumnsCellMaxY;
}
// Draw columns borders and handle resize at the time of "closing" a columns set
if (window->DC.ColumnsCount != columns_count && window->DC.ColumnsCount != 1 && window->DC.ColumnsShowBorders && !window->SkipItems)
{
const float y1 = window->DC.ColumnsStartPosY;
const float y2 = window->DC.CursorPos.y;
for (int i = 1; i < window->DC.ColumnsCount; i++)
{
float x = window->Pos.x + GetColumnOffset(i);
const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(i);
const ImRect column_rect(ImVec2(x-4,y1),ImVec2(x+4,y2));
if (IsClippedEx(column_rect, &column_id, false))
continue;
bool hovered, held;
ButtonBehavior(column_rect, column_id, &hovered, &held, true);
if (hovered || held)
g.MouseCursor = ImGuiMouseCursor_ResizeEW;
// Draw before resize so our items positioning are in sync with the line being drawn
const ImU32 col = GetColorU32(held ? ImGuiCol_ColumnActive : hovered ? ImGuiCol_ColumnHovered : ImGuiCol_Column);
const float xi = (float)(int)x;
window->DrawList->AddLine(ImVec2(xi, y1+1.0f), ImVec2(xi, y2), col);
if (held)
{
if (g.ActiveIdIsJustActivated)
g.ActiveClickDeltaToCenter.x = x - g.IO.MousePos.x;
x = GetDraggedColumnOffset(i);
SetColumnOffset(i, x);
}
}
}
// Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
// In addition, when an identifier isn't explicitly provided we include the number of columns in the hash to make it uniquer.
ImGui::PushID(0x11223347 + (id ? 0 : columns_count));
window->DC.ColumnsSetID = window->GetID(id ? id : "columns");
ImGui::PopID();
// Set state for first column
window->DC.ColumnsCurrent = 0;
window->DC.ColumnsCount = columns_count;
window->DC.ColumnsShowBorders = border;
const float content_region_width = window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x;
window->DC.ColumnsMinX = window->DC.IndentX; // Lock our horizontal range
window->DC.ColumnsMaxX = content_region_width - window->Scroll.x - ((window->Flags & ImGuiWindowFlags_NoScrollbar) ? 0 : g.Style.ScrollbarSize);// - window->WindowPadding().x;
window->DC.ColumnsStartPosY = window->DC.CursorPos.y;
window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY = window->DC.CursorPos.y;
window->DC.ColumnsOffsetX = 0.0f;
window->DC.CursorPos.x = (float)(int)(window->Pos.x + window->DC.IndentX + window->DC.ColumnsOffsetX);
if (window->DC.ColumnsCount != 1)
{
// Cache column offsets
window->DC.ColumnsData.resize(columns_count + 1);
for (int column_index = 0; column_index < columns_count + 1; column_index++)
{
const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
KeepAliveID(column_id);
const float default_t = column_index / (float)window->DC.ColumnsCount;
const float t = window->DC.StateStorage->GetFloat(column_id, default_t); // Cheaply store our floating point value inside the integer (could store an union into the map?)
window->DC.ColumnsData[column_index].OffsetNorm = t;
}
window->DrawList->ChannelsSplit(window->DC.ColumnsCount);
PushColumnClipRect();
ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);
}
else
{
window->DC.ColumnsData.resize(0);
}
}
void ImGui::Indent()
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
window->DC.IndentX += g.Style.IndentSpacing;
window->DC.CursorPos.x = window->Pos.x + window->DC.IndentX + window->DC.ColumnsOffsetX;
}
void ImGui::Unindent()
{
ImGuiState& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
window->DC.IndentX -= g.Style.IndentSpacing;
window->DC.CursorPos.x = window->Pos.x + window->DC.IndentX + window->DC.ColumnsOffsetX;
}
void ImGui::TreePush(const char* str_id)
{
ImGuiWindow* window = GetCurrentWindow();
ImGui::Indent();
window->DC.TreeDepth++;
PushID(str_id ? str_id : "#TreePush");
}
void ImGui::TreePush(const void* ptr_id)
{
ImGuiWindow* window = GetCurrentWindow();
ImGui::Indent();
window->DC.TreeDepth++;
PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}
void ImGui::TreePop()
{
ImGuiWindow* window = GetCurrentWindow();
ImGui::Unindent();
window->DC.TreeDepth--;
PopID();
}
void ImGui::Value(const char* prefix, bool b)
{
ImGui::Text("%s: %s", prefix, (b ? "true" : "false"));
}
void ImGui::Value(const char* prefix, int v)
{
ImGui::Text("%s: %d", prefix, v);
}
void ImGui::Value(const char* prefix, unsigned int v)
{
ImGui::Text("%s: %d", prefix, v);
}
void ImGui::Value(const char* prefix, float v, const char* float_format)
{
if (float_format)
{
char fmt[64];
ImFormatString(fmt, IM_ARRAYSIZE(fmt), "%%s: %s", float_format);
ImGui::Text(fmt, prefix, v);
}
else
{
ImGui::Text("%s: %.3f", prefix, v);
}
}
// FIXME: May want to remove those helpers?
void ImGui::ValueColor(const char* prefix, const ImVec4& v)
{
ImGui::Text("%s: (%.2f,%.2f,%.2f,%.2f)", prefix, v.x, v.y, v.z, v.w);
ImGui::SameLine();
ImGui::ColorButton(v, true);
}
void ImGui::ValueColor(const char* prefix, unsigned int v)
{
ImGui::Text("%s: %08X", prefix, v);
ImGui::SameLine();
ImVec4 col;
col.x = (float)((v >> 0) & 0xFF) / 255.0f;
col.y = (float)((v >> 8) & 0xFF) / 255.0f;
col.z = (float)((v >> 16) & 0xFF) / 255.0f;
col.w = (float)((v >> 24) & 0xFF) / 255.0f;
ImGui::ColorButton(col, true);
}
//-----------------------------------------------------------------------------
// PLATFORM DEPENDANT HELPERS
//-----------------------------------------------------------------------------
#if defined(_WIN32) && !defined(_WINDOWS_) && (!defined(IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS) || !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS))
#undef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
// Win32 API clipboard implementation
#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS)
#ifdef _MSC_VER
#pragma comment(lib, "user32")
#endif
static const char* GetClipboardTextFn_DefaultImpl()
{
static char* buf_local = NULL;
if (buf_local)
{
ImGui::MemFree(buf_local);
buf_local = NULL;
}
if (!OpenClipboard(NULL))
return NULL;
HANDLE wbuf_handle = GetClipboardData(CF_UNICODETEXT);
if (wbuf_handle == NULL)
return NULL;
if (ImWchar* wbuf_global = (ImWchar*)GlobalLock(wbuf_handle))
{
int buf_len = ImTextCountUtf8BytesFromStr(wbuf_global, NULL) + 1;
buf_local = (char*)ImGui::MemAlloc(buf_len * sizeof(char));
ImTextStrToUtf8(buf_local, buf_len, wbuf_global, NULL);
}
GlobalUnlock(wbuf_handle);
CloseClipboard();
return buf_local;
}
static void SetClipboardTextFn_DefaultImpl(const char* text)
{
if (!OpenClipboard(NULL))
return;
const int wbuf_length = ImTextCountCharsFromUtf8(text, NULL) + 1;
HGLOBAL wbuf_handle = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)wbuf_length * sizeof(ImWchar));
if (wbuf_handle == NULL)
return;
ImWchar* wbuf_global = (ImWchar*)GlobalLock(wbuf_handle);
ImTextStrFromUtf8(wbuf_global, wbuf_length, text, NULL);
GlobalUnlock(wbuf_handle);
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT, wbuf_handle);
CloseClipboard();
}
#else
// Local ImGui-only clipboard implementation, if user hasn't defined better clipboard handlers
static const char* GetClipboardTextFn_DefaultImpl()
{
return GImGui->PrivateClipboard;
}
// Local ImGui-only clipboard implementation, if user hasn't defined better clipboard handlers
static void SetClipboardTextFn_DefaultImpl(const char* text)
{
ImGuiState& g = *GImGui;
if (g.PrivateClipboard)
{
ImGui::MemFree(g.PrivateClipboard);
g.PrivateClipboard = NULL;
}
const char* text_end = text + strlen(text);
g.PrivateClipboard = (char*)ImGui::MemAlloc((size_t)(text_end - text) + 1);
memcpy(g.PrivateClipboard, text, (size_t)(text_end - text));
g.PrivateClipboard[(int)(text_end - text)] = 0;
}
#endif
// Win32 API IME support (for Asian languages, etc.)
#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS)
#include <imm.h>
#ifdef _MSC_VER
#pragma comment(lib, "imm32")
#endif
static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y)
{
// Notify OS Input Method Editor of text input position
if (HWND hwnd = (HWND)GImGui->IO.ImeWindowHandle)
if (HIMC himc = ImmGetContext(hwnd))
{
COMPOSITIONFORM cf;
cf.ptCurrentPos.x = x;
cf.ptCurrentPos.y = y;
cf.dwStyle = CFS_FORCE_POSITION;
ImmSetCompositionWindow(himc, &cf);
}
}
#else
static void ImeSetInputScreenPosFn_DefaultImpl(int, int) {}
#endif
//-----------------------------------------------------------------------------
// HELP
//-----------------------------------------------------------------------------
void ImGui::ShowMetricsWindow(bool* opened)
{
if (ImGui::Begin("ImGui Metrics", opened))
{
ImGui::Text("ImGui %s", ImGui::GetVersion());
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::Text("%d vertices, %d indices (%d triangles)", ImGui::GetIO().MetricsRenderVertices, ImGui::GetIO().MetricsRenderIndices, ImGui::GetIO().MetricsRenderIndices / 3);
ImGui::Text("%d allocations", ImGui::GetIO().MetricsAllocs);
static bool show_clip_rects = true;
ImGui::Checkbox("Show clipping rectangles when hovering a ImDrawCmd", &show_clip_rects);
ImGui::Separator();
struct Funcs
{
static void NodeDrawList(ImDrawList* draw_list, const char* label)
{
bool node_opened = ImGui::TreeNode(draw_list, "%s: '%s' %d vtx, %d indices, %d cmds", label, draw_list->_OwnerName ? draw_list->_OwnerName : "", draw_list->VtxBuffer.Size, draw_list->IdxBuffer.Size, draw_list->CmdBuffer.Size);
if (draw_list == ImGui::GetWindowDrawList())
{
ImGui::SameLine();
ImGui::TextColored(ImColor(255,100,100), "CURRENTLY APPENDING"); // Can't display stats for active draw list! (we don't have the data double-buffered)
if (node_opened) ImGui::TreePop();
return;
}
if (!node_opened)
return;
ImDrawList* overlay_draw_list = &GImGui->OverlayDrawList; // Render additional visuals into the top-most draw list
overlay_draw_list->PushClipRectFullScreen();
int elem_offset = 0;
for (const ImDrawCmd* pcmd = draw_list->CmdBuffer.begin(); pcmd < draw_list->CmdBuffer.end(); elem_offset += pcmd->ElemCount, pcmd++)
{
if (pcmd->UserCallback)
{
ImGui::BulletText("Callback %p, user_data %p", pcmd->UserCallback, pcmd->UserCallbackData);
continue;
}
bool draw_opened = ImGui::TreeNode((void*)(pcmd - draw_list->CmdBuffer.begin()), "Draw %-4d %s vtx, tex = %p, clip_rect = (%.0f,%.0f)..(%.0f,%.0f)", pcmd->ElemCount, draw_list->IdxBuffer.Size > 0 ? "indexed" : "non-indexed", pcmd->TextureId, pcmd->ClipRect.x, pcmd->ClipRect.y, pcmd->ClipRect.z, pcmd->ClipRect.w);
if (show_clip_rects && ImGui::IsItemHovered())
{
ImRect clip_rect = pcmd->ClipRect;
ImRect vtxs_rect;
ImDrawIdx* idx_buffer = (draw_list->IdxBuffer.Size > 0) ? draw_list->IdxBuffer.Data : NULL;
for (int i = elem_offset; i < elem_offset + (int)pcmd->ElemCount; i++)
vtxs_rect.Add(draw_list->VtxBuffer[idx_buffer ? idx_buffer[i] : i].pos);
clip_rect.Round(); overlay_draw_list->AddRect(clip_rect.Min, clip_rect.Max, ImColor(255,255,0));
vtxs_rect.Round(); overlay_draw_list->AddRect(vtxs_rect.Min, vtxs_rect.Max, ImColor(255,0,255));
}
if (!draw_opened)
continue;
for (int i = elem_offset; i+2 < elem_offset + (int)pcmd->ElemCount; i += 3)
{
ImVec2 triangles_pos[3];
char buf[300], *buf_p = buf;
for (int n = 0; n < 3; n++)
{
ImDrawVert& v = draw_list->VtxBuffer[(draw_list->IdxBuffer.Size > 0) ? draw_list->IdxBuffer.Data[i+n] : i+n];
triangles_pos[n] = v.pos;
buf_p += sprintf(buf_p, "vtx %04d { pos = (%8.2f,%8.2f), uv = (%.6f,%.6f), col = %08X }\n", i+n, v.pos.x, v.pos.y, v.uv.x, v.uv.y, v.col);
}
ImGui::Selectable(buf, false);
if (ImGui::IsItemHovered())
overlay_draw_list->AddPolyline(triangles_pos, 3, ImColor(255,255,0), true, 1.0f, false); // Add triangle without AA, more readable for large-thin triangle
}
ImGui::TreePop();
}
overlay_draw_list->PopClipRect();
ImGui::TreePop();
}
static void NodeWindows(ImVector<ImGuiWindow*>& windows, const char* label)
{
if (!ImGui::TreeNode(label, "%s (%d)", label, windows.Size))
return;
for (int i = 0; i < windows.Size; i++)
Funcs::NodeWindow(windows[i], "Window");
ImGui::TreePop();
}
static void NodeWindow(ImGuiWindow* window, const char* label)
{
if (!ImGui::TreeNode(window, "%s '%s', %d @ 0x%p", label, window->Name, window->Active || window->WasActive, window))
return;
NodeDrawList(window->DrawList, "DrawList");
if (window->RootWindow != window) NodeWindow(window->RootWindow, "RootWindow");
if (window->DC.ChildWindows.Size > 0) NodeWindows(window->DC.ChildWindows, "ChildWindows");
ImGui::BulletText("Storage: %d bytes", window->StateStorage.Data.Size * (int)sizeof(ImGuiStorage::Pair));
ImGui::TreePop();
}
};
ImGuiState& g = *GImGui; // Access private state
Funcs::NodeWindows(g.Windows, "Windows");
if (ImGui::TreeNode("DrawList", "Active DrawLists (%d)", g.RenderDrawLists[0].Size))
{
for (int i = 0; i < g.RenderDrawLists[0].Size; i++)
Funcs::NodeDrawList(g.RenderDrawLists[0][i], "DrawList");
ImGui::TreePop();
}
if (ImGui::TreeNode("Popups", "Opened Popups Stack (%d)", g.OpenedPopupStack.Size))
{
for (int i = 0; i < g.OpenedPopupStack.Size; i++)
{
ImGuiWindow* window = g.OpenedPopupStack[i].Window;
ImGui::BulletText("PopupID: %08x, Window: '%s'%s%s", g.OpenedPopupStack[i].PopupID, window ? window->Name : "NULL", window && (window->Flags & ImGuiWindowFlags_ChildWindow) ? " ChildWindow" : "", window && (window->Flags & ImGuiWindowFlags_ChildMenu) ? " ChildMenu" : "");
}
ImGui::TreePop();
}
if (ImGui::TreeNode("Basic state"))
{
ImGui::Text("FocusedWindow: '%s'", g.FocusedWindow ? g.FocusedWindow->Name : "NULL");
ImGui::Text("HoveredWindow: '%s'", g.HoveredWindow ? g.HoveredWindow->Name : "NULL");
ImGui::Text("HoveredRootWindow: '%s'", g.HoveredRootWindow ? g.HoveredRootWindow->Name : "NULL");
ImGui::Text("HoveredID: 0x%08X/0x%08X", g.HoveredId, g.HoveredIdPreviousFrame); // Data is "in-flight" so depending on when the Metrics window is called we may see current frame information or not
ImGui::Text("ActiveID: 0x%08X/0x%08X", g.ActiveId, g.ActiveIdPreviousFrame);
ImGui::TreePop();
}
}
ImGui::End();
}
//-----------------------------------------------------------------------------
// Include imgui_user.inl at the end of imgui.cpp to access private data/functions that aren't exposed.
// Prefer just including imgui_internal.h from your code rather than using this define. If a declaration is missing from imgui_internal.h add it or request it on the github.
#ifdef IMGUI_INCLUDE_IMGUI_USER_INL
#include "imgui_user.inl"
#endif
//-----------------------------------------------------------------------------
| [
"[email protected]"
] | |
620c5cf0b31a1e65949e99bc5060ed829c315de4 | bfbacd036bee71d44373db54277c6505a1d1edee | /src/CameraParams.cpp | eff059eee388291d5448f13b1d044fc20b15abd8 | [] | no_license | Subtlemon/image_reprojection_2016 | f53253424dd9689b035175b6bac7fa65a0c39206 | 0d980ed0ac14e6cffe8568fbcf7c77512f14d8fa | refs/heads/master | 2021-01-11T04:13:06.101434 | 2016-10-18T08:50:57 | 2016-10-18T08:50:57 | 71,205,259 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,591 | cpp | #include "CameraParams.h"
#include <math.h>
#include <iostream>
#ifndef PI
#define PI 3.14159265358979323846
#endif
/**
* @brief Simple Constructor.
*
* @param[in] altitude Altitude of plane (in any unit).
* @param[in] FOV_x Field of view along x-axis of camera (degrees).
* @param[in] FOV_y Field of view along y-axis of camera (degrees).
* @param[in] width Width of camera (pixels).
* @param[in] height Height of camera (pixels).
* @param[in] roll Roll angle of plane (degrees) (rotation around y-axis of camera).
* @param[in] pitch Pitch angle of plane (degrees) (rotation around x-axis of camera).
* @param[in] yaw Yaw angle of plane (degrees) (rotation around z-axis of camera)
*/
CameraParams::CameraParams(double altitude, double FOV_x, double FOV_y, int width, int height, double roll, double pitch, double yaw) {
if (roll > 45) {
std::cout << "Warning: Don't bother with roll > 45 degrees" << std::endl;
roll = 45;
}
else if (roll < -45) {
std::cout << "Warning: Don't bother with roll < -45 degrees" << std::endl;
roll = -45;
}
if (pitch > 45) {
std::cout << "Warning: Don't bother with pitch > 45 degrees" << std::endl;
pitch = 45;
}
else if (pitch < -45) {
pitch = -45;
std::cout << "Warning: Don't bother with pitch < -45 degrees" << std::endl;
}
if (FOV_x > 60) {
std::cout << "Warning: Don't bother with FOV_x > 60 degrees" << std::endl;
FOV_x = 60;
}
else if (FOV_x < 1) {
std::cout << "Warning: FOV_x = " << FOV_x << " which makes no sense" << std::endl;
FOV_x = 1;
}
if (FOV_y > 60) {
std::cout << "Warning: Don't bother with FOV_y > 60 degrees" << std::endl;
FOV_y = 60;
}
else if (FOV_y < 1) {
std::cout << "Warning: FOV_y = " << FOV_y << " which makes no sense" << std::endl;
FOV_y = 1;
}
if (width < 1) {
std::cout << "Warning: width " << width << " makes no sense" << std::endl;
width = 1920;
}
if (height < 1) {
std::cout << "Warning: height " << height << " makes no sense" << std::endl;
height = 1080;
}
if (altitude <= 0) {
std::cout << "Warning: altitude " << altitude << " makes no sense" << std::endl;
altitude = 1;
}
this->altitude = altitude;
this->FOV_x = FOV_x * PI / 180.;
this->FOV_y = FOV_y * PI / 180.;
this->width = width;
this->height = height;
this->roll = roll * PI / 180.;
this->pitch = pitch * PI / 180.;
this->yaw = yaw * PI / 180.;
}
/**
* @brief Empty Destructor.
*/
CameraParams::~CameraParams(){
// nothing to destruct
}
/**
* @brief Calculate the distance to a point on the ground.
*
* Calculates the distance between the camera and a location on the ground,
* based on its pixel location in the image.
*
* @param[in] x The X coordinate of the pixel (min = 0, max = maxX).
* @param[in] y The Y coordinate of the pixel (min = 0, max = maxX).
* @param[out] east The distance east of the camera location (same units as altitude).
* @param[out] north The distance north of the camera location (same units as altitude).
*/
void CameraParams::calcDistance(int x, int y, double& east, double& north) {
// define a unit vectors for X Y and Z
double ux[4] = {1., 0., 0., 1.};
double uy[4] = {0., 1., 0., 1.};
double uz[4] = {0., 0., 1., 1.};
// rotate the coordinate axis for yaw
rotateAbout(uz, yaw, ux);
rotateAbout(uz, yaw, uy);
// rotate the coordinate axis for pitch
rotateAbout(ux, 0-pitch, uy);
rotateAbout(ux, 0-pitch, uz);
// rotate the coordinate axis for roll
rotateAbout(uy, roll, ux);
rotateAbout(uy, roll, uz);
// check lengths of unit vectors
// create a vector pointing in the negative x coordinate axis
double u[3] = {0-uz[0], 0-uz[1], 0-uz[2]};
// add x-axis to said vector to account for x position within the picture
double factor = findXoverZ(x, width, FOV_x, 0);
u[0] += factor * ux[0];
u[1] += factor * ux[1];
u[2] += factor * ux[2];
factor = findXoverZ(y, height, FOV_y, 0);
u[0] += factor * uy[0];
u[1] += factor * uy[1];
u[2] += factor * uy[2];
double multiple = 0-altitude/u[2];
east = multiple * u[0];
north = multiple * u[1];
}
/**
* @brief Calculate the change in X per unit Z.
*
* This function can be reused for Y, if you use the right FOV and the pitch
* instead of roll for tilt.
*
* @param[in] x Pixel location of X.
* @param[in] maxX Image width.
* @param[in] FOV Field of view along x.
* @param[in] tilt Tilt along x-axis.
*/
double CameraParams::findXoverZ(int x, int width, double FOV, double tilt) {
// Given the FOV, the furthest ray and middle ray (and by approximation,
// all the rays) converge at distance d behind the lens, where d is
// measured in pixels.
double d = width / 2 / tan(FOV);
// If we put an imaginary stick of length d behind the lens at the
// midpoint, the line passing through pixel x makes an angle alpha with
// the imaginary line d.
double alpha = atan(((double)x-(double)width/2.) / d);
// Since the plane is tilted at angle tilt, the ray passing through the tip
// of d and the pixel x makes angle theta with the normal to the ground (Z).
double theta = alpha + tilt;
// tan(theta) = deltaX / 1;
return tan(theta);
}
/**
* @brief Rotates a vector along the x-axis.
*/
void CameraParams::rotateX(double u[3], double theta) {
double sine = sin(theta);
double cosine = cos(theta);
// u[0] untouched
u[1] = u[1] * cosine + u[2] * sine;
u[2] = 0-u[1] * sine + u[2] * cosine;
}
/**
* @brief Rotates a vector along the y-axis.
*/
void CameraParams::rotateY(double u[3], double theta) {
double sine = sin(theta);
double cosine = cos(theta);
u[0] = u[0] * cosine - u[2] * sine;
// u[1] untouched
u[2] = u[2] * cosine + u[0] * sine;
}
/**
* @brief Rotates a vector along the z-axis.
*/
void CameraParams::rotateZ(double u[3], double theta) {
double sine = sin(theta);
double cosine = cos(theta);
u[0] = u[0] * cosine - u[1] * sine;
u[1] = 0-u[0] * sine + u[1] * cosine;
// u[2] untouched
}
/**
* @brief Rotates a vector along any axis.
*/
void CameraParams::rotateAbout(const double axis[4], double theta, double inout[4]) {
// set up rotation matrix
double rotationMatrix[4][4];
double u = axis[0], v = axis[1], w = axis[2];
double u2 = u * u, v2 = v * v, w2 = w * w;
double L = (u2 + v2 + w2);
double l = sqrt(L);
double cosine = cos(theta), sine = sin(theta);
rotationMatrix[0][0] = (u2 + (v2 + w2) * cosine) / L;
rotationMatrix[0][1] = (u * v * (1 - cosine) - w * l * sine) / L;
rotationMatrix[0][2] = (u * w * (1 - cosine) + v * l * sine) / L;
rotationMatrix[0][3] = 0.0;
rotationMatrix[1][0] = (u * v * (1 - cosine) + w * l * sine) / L;
rotationMatrix[1][1] = (v2 + (u2 + w2) * cosine) / L;
rotationMatrix[1][2] = (v * w * (1 - cosine) - u * l * sine) / L;
rotationMatrix[1][3] = 0.0;
rotationMatrix[2][0] = (u * w * (1 - cosine) - v * l * sine) / L;
rotationMatrix[2][1] = (v * w * (1 - cosine) + u * l * sine) / L;
rotationMatrix[2][2] = (w2 + (u2 + v2) * cosine) / L;
rotationMatrix[2][3] = 0.0;
rotationMatrix[3][0] = 0.0;
rotationMatrix[3][1] = 0.0;
rotationMatrix[3][2] = 0.0;
rotationMatrix[3][3] = 1.0;
// make output and multiply
double output[4];
for (int c=0; c<4; ++c) {
output[c] = 0;
for (int k=0; k<4; k++) {
output[c] += rotationMatrix[c][k] * inout[k];
}
}
// copy into inout
for (int c=0; c<4; ++c) {
inout[c] = output[c];
}
}
/**
* @brief Finds the angle at which the pixel is relative to the focal point.
*/
double CameraParams::findAngle(int x, int width, double FOV) {
// Given the FOV, the furthest ray and middle ray (and by approximation,
// all the rays) converge at distance d behind the lens, where d is
// measured in pixels.
double d = width / 2 / tan(FOV);
// If we put an imaginary stick of length d behind the lens at the
// midpoint, the line passing through pixel x makes an angle alpha with
// the imaginary line d.
return atan(((double)x-(double)width/2) / d);
}
/**
* @brief Prints a vector.
*/
void CameraParams::printVector(const double u[3]) {
std::cout << "X: " << u[0] << " Y: " << u[1] << " Z: " << u[2] << std::endl;
}
| [
"[email protected]"
] | |
2a1c92fccb87ef7f97637bde0aebe5d4bdbb451e | d28ef2a19bbd61553219434bda4d40046012d0e2 | /InAppPurchases/ApplicationCallbacksInitPlugin.h | 8da171297f6cd6cc973fcfa8d576b8b34cb6fa91 | [
"Apache-2.0"
] | permissive | razerofficial/marmalade-plugin-razer-sdk | be7ac5ce81f44ace523b0c31809bb5c5c0cfd14e | 3fc647cb2e36918f6fba61240771e7885725d920 | refs/heads/master | 2020-07-08T10:20:02.833188 | 2016-10-04T18:19:45 | 2016-10-04T18:19:45 | 66,681,236 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 841 | h | /*
* Copyright (C) 2012-2016 Razer, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <string>
class ApplicationCallbacksInitPlugin
{
public:
s3eCallback GetSuccessEvent();
s3eCallback GetFailureEvent();
void OnSuccess();
void OnFailure(int errorCode, const std::string& errorMessage);
};
| [
"[email protected]"
] | |
23473c9c66fdf49471846a89f0b5b7a5c51a422c | 83810fbfb76c6cef3591507dfacbd8eaf1097bac | /TorentMakerConsoleApplication/DxHelpres/DxDeviceMt.cpp | 7545e42e9e106b1790a3307951c32921a387701d | [
"MIT"
] | permissive | sssr33/TorrentMaker | 3c03126a611fad54e9df48fae87c6e8c75e4a64e | 75dc4b7b45c3c277342470f705e4a35264f942f7 | refs/heads/master | 2021-01-10T03:25:52.137480 | 2016-01-16T21:29:56 | 2016-01-16T21:29:56 | 47,291,238 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 430 | cpp | #include "DxDeviceMt.h"
IDWriteFactory *DxDeviceMt::GetDwriteFactory() const {
return this->dwriteFactory.Get();
}
ID2D1Factory1 *DxDeviceMt::GetD2DFactory() const {
return this->d2dFactory.Get();
}
ID3D11Device *DxDeviceMt::GetD3DDevice() const {
return this->d3dDev.Get();
}
ID2D1Device *DxDeviceMt::GetD2DDevice() const {
return this->d2dDevice.Get();
}
D2DCtxMt *DxDeviceMt::GetD2DCtxMt() {
return &this->d2dCtxMt;
} | [
"[email protected]"
] | |
c3e000468afa7673f376aa40e42ffaf01e759618 | 9ed0ca49d7fddf6ecb1784d15709a3235cba37b4 | /Source/Tools/Builder/BuildServer.cpp | 6a609504cb24894a06601ef5fbc51c8d8e39a647 | [
"MIT"
] | permissive | simeks/Sandbox | 1332422161924dd490bd70cac8d791a6bfb67492 | 394b7ab774b172b6e8bc560eb2740620a8dee399 | refs/heads/master | 2020-05-17T08:45:03.388896 | 2017-03-05T14:10:37 | 2017-03-05T14:10:37 | 83,967,032 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 14,045 | cpp | // Copyright 2008-2014 Simon Ekström
#include "Common.h"
#include "BuildServer.h"
#include "ShaderDatabase.h"
#include "DependencyDatabase.h"
#include "BuildUICallback.h"
#include <Foundation/Debug/Console.h>
#include <Foundation/Debug/ConsoleServer.h>
#include <Foundation/Filesystem/DirectoryWatcher.h>
#include <Foundation/Filesystem/FilePath.h>
#include <Foundation/Filesystem/FileUtil.h>
#include <Foundation/Json/Json.h>
#include <Foundation/Container/StringIdRepository.h>
#include "MaterialCompiler.h"
#include "ShaderCompiler.h"
#include "TextureCompiler.h"
#include "MeshCompiler.h"
#include "ScriptCompiler.h"
#include "PackageCompiler.h"
#include "CopyCompiler.h"
#include "FontCompiler.h"
namespace sb
{
namespace
{
static const char* level_to_string[] = {
/* LOG_INFO */ "info",
/* LOG_WARNING */ "warning",
/* LOG_ERROR */ "error"
};
void LoggingCallback(void* data, Log::LogLevel level, const char* msg)
{
ConsoleServer* console = (ConsoleServer*)data;
if (console)
{
ConfigValue msg_data;
msg_data.SetEmptyObject();
msg_data["type"].SetString("log_msg");
msg_data["level"].SetString(level_to_string[level]);
msg_data["msg"].SetString(msg);
console->Send(msg_data);
}
printf("%s\n", msg);
}
}
namespace build_server_commands
{
void FullRebuild(void* user_data, const ConfigValue&)
{
BuildServer* server = (BuildServer*)user_data;
server->FullRebuild();
}
void StringIdLookup(void* user_data, const ConfigValue& cmd)
{
if (cmd["args"].Size() == 0 || !cmd["args"][0].IsString())
{
logging::Info("Usage: string_id_lookup <string_id>");
logging::Info("Example: string_id_lookup 0xAABBCCDD");
return;
}
const char* hex_str = cmd["args"][0].AsString();
uint32_t str_len = (uint32_t)strlen(hex_str);
if (str_len < 2 || hex_str[0] != '0' || (hex_str[1] != 'x' && hex_str[1] != 'X'))
{
logging::Info("Wrong format of string id, expecting:");
logging::Info("\t0xAABBCCDD\t\t: For 32bit string identifiers");
logging::Info("\t0x11223344AABBCCDD\t: For 64bit string identifiers");
return;
}
StringIdRepository* repo = (StringIdRepository*)user_data;
Assert(repo);
const char* result;
if (str_len <= 10)
{
uint32_t id;
id = strtoul(hex_str, NULL, 0);
result = repo->LookUp(id);
}
else
{
uint64_t id;
id = _strtoui64(hex_str, NULL, 0);
result = repo->LookUp(id);
}
if (result)
logging::Info("%s => \"%s\"", hex_str, result);
else
logging::Info("No match found.");
}
};
BuildServer::BuildServer(const BuilderParams& params)
: _file_system(params.base_path.c_str()),
_params(params),
_stop(false),
_dependency_database(NULL),
_shader_database(NULL),
_callback(NULL),
_active_settings(NULL)
{
logging::SetCallback(LoggingCallback, nullptr);
logging::Info("*** Running Builder ***");
_source = _file_system.OpenFileSource(params.source_path.c_str());
_target = _file_system.OpenFileSource(params.target_path.c_str());
// Make sure target directory exists
_file_system.MakeDirectory(params.target_path.c_str());
// Make sure .builder folder exists
_source->MakeDirectory(".builder");
_dependency_database = new DependencyDatabase(_source);
_shader_database = new ShaderDatabase(_source);
_string_id_repository = new StringIdRepository(_source, ".builder/string_id_repository");
_string_id_repository->Load();
string_id::SetRepository(_string_id_repository);
if (_params.server) // No need to watch directories if we're not running in server mode
{
_dir_watcher = new DirectoryWatcher(_source->GetFullPath().c_str(), true);
}
ConfigValue settings_cfg;
simplified_json::Reader reader;
if (!reader.ReadFile(_source, "builder.settings", settings_cfg))
{
logging::Warning("Failed to load builder settings: %s", reader.GetErrorMessage().c_str());
return;
}
if (_params.server && (settings_cfg["console_server_port"].IsNumber())) // No need to start the console server if we're not running in server mode
{
console::Initialize(settings_cfg["console_server_port"].AsInt());
logging::SetCallback(LoggingCallback, (void*)console::Server());
}
if (settings_cfg["setting_profiles"].IsObject())
{
ConfigValueConstIterator prof_it = settings_cfg["setting_profiles"].Begin(),
prof_end = settings_cfg["setting_profiles"].End();
for (; prof_it != prof_end; ++prof_it)
{
BuildSettings* settings = new BuildSettings();
build_settings::Load(prof_it->second, *settings);
_setting_profiles[prof_it->first] = settings;
if (!_active_settings)
_active_settings = settings;
}
}
if (_setting_profiles.empty())
{
logging::Warning("No setting profiles defined, setting to default.");
_active_settings = new BuildSettings();
_setting_profiles["default"] = _active_settings;
}
_compiler_system = new CompilerSystem(this, _source, _target, _dependency_database, _shader_database, _active_settings);
RegisterCompilers(settings_cfg["compilers"]);
// Parse ignore list
if (settings_cfg["ignore_list"].IsArray())
{
for (uint32_t i = 0; i < settings_cfg["ignore_list"].Size(); ++i)
{
if (settings_cfg["ignore_list"][i].IsString())
_compiler_system->AddIgnoreAsset(settings_cfg["ignore_list"][i].AsString());
}
}
ADD_CONSOLE_COMMAND("full_rebuild", build_server_commands::FullRebuild, this, "Rebuilds all assets.");
ADD_CONSOLE_COMMAND("string_id_lookup", build_server_commands::StringIdLookup, _string_id_repository, "Looks up a string from a string identifier.");
}
BuildServer::~BuildServer()
{
for (CompilerSystem::Compiler* compiler : _compilers)
{
delete compiler;
}
_compilers.clear();
_active_settings = NULL;
if (!_setting_profiles.empty())
{
for (auto& settings : _setting_profiles)
{
delete settings.second;
}
_setting_profiles.clear();
}
if (_params.server)
{
delete _dir_watcher;
}
_shader_database->Save();
_dependency_database->Save();
_string_id_repository->Save();
string_id::SetRepository(NULL);
delete _compiler_system;
delete _shader_database;
delete _dependency_database;
delete _string_id_repository;
_file_system.CloseFileSource(_source);
_file_system.CloseFileSource(_target);
if (_params.server && console::Initialized())
{
logging::SetCallback(NULL, NULL);
console::Shutdown();
}
}
void BuildServer::SetCallback(BuildUICallback* callback)
{
_callback = callback;
}
void BuildServer::Run()
{
bool force_compile = false;
if (!_dependency_database->Load() || !_shader_database->Load()) // Force a complete compile if the dependency/shader database failed to load
{
logging::Info("Missing shader or dependency database: Forcing a full compile");
force_compile = true;
}
if (force_compile || _params.force_recompile)
{
FullRebuild();
}
else
{
PartialRebuild();
}
if (!_params.server)
{
Stop();
return;
}
vector<Action> actions;
vector<AssetSource> changes;
vector<DirectoryChange> pending_changes;
DirectoryChange dir_change;
while (!_stop)
{
// Handle any directory changes
while (_dir_watcher->PopChange(dir_change))
{
FilePath path(dir_change.path);
path.SetSeparator('/');
if (path.Directory() == ".builder/") // Skip .builder as builder uses that directory internally
continue;
// Windows always sends two FILE_MODIFIED notifications when a file is modified,
// to make sure we only dispatch the asset to the compiler when the file is actually
// ready we let the first notifaction pend until the second one arrives.
if (dir_change.action != DirectoryChange::FILE_MODIFIED)
changes.push_back(AssetSource(path.c_str()));
// Filter any duplicated notifications as we always get two when file is modified
bool found = false;
for (vector<DirectoryChange>::iterator it = pending_changes.begin(); it != pending_changes.end(); ++it)
{
if (it->path == dir_change.path) // this is the second notifaction
{
found = true;
changes.push_back(AssetSource(path.c_str()));
pending_changes.erase(it);
break;
}
}
if (!found)
pending_changes.push_back(dir_change);
}
if (!changes.empty())
{
// If we dispatch the changed file to the compiler to quickly it won't be able to open the source file
// as the file is already opened by another program.
Sleep(100); // TODO: Find better solution than this maybe?
_compiler_system->Compile(changes.data(), (uint32_t)changes.size(), false, _callback);
changes.clear();
}
if (_shader_database->IsDirty())
{
_shader_database->GetDirtyShaders(changes);
if (!changes.empty())
{
_compiler_system->Compile(changes.data(), (uint32_t)changes.size(), true, _callback);
changes.clear();
}
}
{
ScopedLock<CriticalSection> lock(_action_queue_lock);
if (!_action_queue.empty())
{
actions.push_back(_action_queue.front());
_action_queue.pop();
}
}
if (!actions.empty())
{
for (vector<Action>::iterator it = actions.begin(); it != actions.end(); ++it)
{
switch (*it)
{
case SCAN:
PartialRebuild();
break;
case FULL_REBUILD:
FullRebuild();
break;
case CHANGE_PROFILE:
if (!_queued_profile.empty())
{
_active_settings = _setting_profiles[_queued_profile];
_queued_profile = "";
_compiler_system->SetBuildSettings(_active_settings);
// Trigger full rebuild when changing profile
FullRebuild();
}
break;
};
}
}
actions.clear();
console::Server()->Update();
Sleep(1);
}
}
void BuildServer::Stop()
{
_stop = true;
}
bool BuildServer::IsStopping() const
{
return _stop;
}
void BuildServer::QueueFullRebuild()
{
ScopedLock<CriticalSection> lock(_action_queue_lock);
_action_queue.push(FULL_REBUILD);
}
void BuildServer::QueueScan()
{
ScopedLock<CriticalSection> lock(_action_queue_lock);
_action_queue.push(SCAN);
}
void BuildServer::SetActiveProfile(const string& profile)
{
_queued_profile = profile;
ScopedLock<CriticalSection> lock(_action_queue_lock);
_action_queue.push(CHANGE_PROFILE);
}
void BuildServer::FullRebuild()
{
// First we clear the dependency database because we will force all assets
// to recompile and therefore we get a new complete database, this will also
// clean out any redundant dependencies that may exist
_dependency_database->Clear();
_shader_database->Clear();
vector<AssetSource> assets;
ScanSourceDirectory(assets);
if (!assets.empty())
{
_compiler_system->Compile(assets.data(), (uint32_t)assets.size(), true, _callback);
}
_dependency_database->Save();
_shader_database->Save();
_string_id_repository->Save();
}
void BuildServer::PartialRebuild()
{
vector<AssetSource> assets;
ScanSourceDirectory(assets);
if (!assets.empty())
{
_compiler_system->Compile(assets.data(), (uint32_t)assets.size(), false, _callback);
}
}
void BuildServer::ScanSourceDirectory(vector<AssetSource>& sources)
{
string find_path;
vector<string> files;
file_util::FindFilesRecursive(_source, "*", files);
for (vector<string>::iterator it = files.begin(); it != files.end(); ++it)
{
if (it->substr(0, 8) == ".builder") // Ignore .builder folder
continue;
sources.push_back(AssetSource(it->c_str()));
}
}
void BuildServer::RegisterCompilers(const ConfigValue& compilers)
{
Assert(compilers.IsArray());
string action;
for (uint32_t i = 0; i < compilers.Size(); ++i)
{
Assert(compilers[i].IsObject());
Assert(compilers[i]["action"].IsString());
Assert(compilers[i]["source_type"].IsString());
action = compilers[i]["action"].AsString();
const char* source_type = compilers[i]["source_type"].AsString();
CompilerSystem::Compiler* compiler;
if (action == "material_compiler")
{
compiler = new MaterialCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "shader_compiler")
{
compiler = new ShaderCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "texture_compiler")
{
compiler = new TextureCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "mesh_compiler")
{
compiler = new MeshCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "script_compiler")
{
compiler = new ScriptCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "package_compiler")
{
compiler = new PackageCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "copy")
{
compiler = new CopyCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else if (action == "font_compiler")
{
compiler = new FontCompiler(compilers[i]);
_compiler_system->RegisterCompiler(source_type, compiler);
_compilers.push_back(compiler);
}
else
{
logging::Warning("Build action '%s' not found", action.c_str());
continue;
}
}
}
const map<string, BuildSettings*>& BuildServer::GetSettingProfiles() const
{
return _setting_profiles;
}
string BuildServer::GetActiveProfile() const
{
Assert(_active_settings);
for (auto& profile : _setting_profiles)
{
if (profile.second == _active_settings)
return profile.first;
}
return "";
}
} // namespace sb
| [
"[email protected]"
] | |
805cd560d4fb6d007e6dba523f57c4fa47954681 | 6536ad9a6c0e04db8866da9a3e54b01216da5f6d | /FilterSam.cpp | bbd6a0c746399c54e695a5a4669cf01b0e0dce73 | [] | no_license | amit21AIT/Cpp-programs-for-conversion-of-SAM-file-into-Fastq-files | ea5aa91c86139768c520b22aa4405a5fa46a33e9 | 08a8932536cb96b39e15aff9630b1d471e8df6c8 | refs/heads/master | 2021-07-07T08:13:22.661225 | 2019-06-20T18:48:42 | 2019-06-20T18:48:42 | 192,970,293 | 0 | 2 | null | 2020-10-01T10:10:15 | 2019-06-20T18:39:51 | C++ | UTF-8 | C++ | false | false | 1,401 | cpp | // this code writes unwanted reads onto the garbage.sam file and good reads into output.sam file
#include <bits/stdc++.h>
#include <fstream>
using namespace std;
int main()
{
ifstream in("input.sam");
ofstream f1("output.sam",ios::out|ios::app);
ofstream f2("garbage.sam",ios::out|ios::app);
string record;
while(getline(in,record))
{
if(record.size()<100) // to ignore the starting lines in sam files which are not required in fastq
continue;
stringstream iterator(record); // making a stream of input string so that we can extract one word at a time
int cnt = 0,num;
string x,seq,qs; // declarations
while(iterator>>x)
{
cnt++;
if(cnt==2)
{
stringstream s(x); // to convert string to integer
s>>num; // flag
}
else if(cnt==10) // DNA sequence
seq = x;
else if(cnt==11) // quality score
qs = x;
}
if(cnt>=11 && seq.size()==qs.size() && num<256) // if seq size and quality score size are equal and flag <256 then only write into the file
f1<<record<<"\n";
else
f2<<record<<"\n"; // else data goes in the garbage file
}
in.close();
f1.close();
f2.close();
}
| [
"[email protected]"
] | |
bb02623f72a96793663b621e09ccaaa3c9f12da0 | 095ef689b5275f7b1d74a5df24b1e1708216027b | /src/capture/device_d3d.h | 49d7bf2060a8426f340f76c8ac44691483506634 | [
"MIT",
"Apache-2.0"
] | permissive | ogukei/cinderella-screen | 17bf2fbb329b6be0512d79d03676b3b21c1420a9 | f3fb188e521cd2d0f960b1ec19d8a28c014d7c53 | refs/heads/master | 2023-08-03T09:56:12.150920 | 2021-09-26T14:47:41 | 2021-09-26T14:47:41 | 406,015,800 | 0 | 0 | MIT | 2021-09-26T14:47:42 | 2021-09-13T14:54:20 | C++ | UTF-8 | C++ | false | false | 556 | h |
#pragma once
#include "winrt_base.hpp"
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Foundation.Collections.h>
#include <winrt/Windows.Graphics.Capture.h>
#include <d3d11.h>
#include <dxgi1_2.h>
namespace imascs {
namespace capture {
winrt::com_ptr<ID3D11Device> CreateD3DDevice();
winrt::com_ptr<IDXGISwapChain1> CreateDXGISwapChain(
winrt::com_ptr<ID3D11Device> const& device,
uint32_t width, uint32_t height,
DXGI_FORMAT format, uint32_t bufferCount);
} // namespace capture
} // namespace imascs
| [
"[email protected]"
] | |
4e3b66666ea2cd3d25472baedbfd01c72f2a578c | 0aa325d6d4e71aa66aa6101781476493bab85d19 | /Talkers/Behaviours/T-13/B-182/O-183.hpp | ba1aa04571cc7b8f8d6074d54b4de38414bbfc8f | [] | no_license | valentin-dufois/Protocol-Bernardo | 7a14004bd85000e7f3cbd25e5952f258c0b9a99c | 0e2225bb7f170e7517d2d55ea5a4aff3667c8ca3 | refs/heads/master | 2022-04-03T09:48:39.971882 | 2020-02-18T22:18:47 | 2020-02-18T22:18:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 856 | hpp | //
// O-183.hpp
// Talkers
//
// Created by Valentin Dufois on 2020-02-03.
//
#ifndef O_183_hpp
#define O_183_hpp
#include "../../Output.hpp"
class O183: public Output {
public:
O183(): Output(183, // Output ID
false, // Is tree end ?
183, // Next Behaviour ID
DELAY_DEFAULT, // Is delayed
DELAY_VALUE_DEFAULT, // Delay value (seconds)
DELAY_VARIANCE_DEFAULT, // Delay variance (seconds)
{ // Output values
},
{ // Captions
"This might be the reason we work together as one.",
}) {}
virtual bool isConditionValid(State &behaviourState) override {
/*
Condition:
*/
return true;
}
};
#endif /* O_183_hpp */
| [
"[email protected]"
] | |
ca16497e6058ad4cfe77d7ea46bf1a94c7f08824 | a406721ca5e28b01f7fbfc7f7ad9d67cf0472a96 | /src/leddriver_dummy.cpp | 0b4fc909807b39a4cdea4c4be8b3dcaea8d80b3f | [
"MIT"
] | permissive | AllegorithmicSAS/esp32-ble-control | 7ca4dd03d48dad006c1c30c78f1afeec46b653cf | 8506057106a484a10666ab064fa4dd64c35858b3 | refs/heads/master | 2018-12-25T09:58:34.740632 | 2018-10-22T14:10:48 | 2018-10-22T14:10:48 | 108,952,668 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,172 | cpp | #include "leddriver.h"
#include <Arduino.h>
#include "logger.h"
static auto Log = Logger("LedDriverDummy");
static const auto DriverInfo = LedDriverInfo{
.nChannels = 1,
.name = "dummy driver"
};
// GPIO on which the built in led is connected (might vary depending on debug board)
// 2,5,16 are common values - some boards don't even have a built in LED
const uint8_t BuiltInLed = 2;
struct LedDriverDummy : public ILedDriver {
protected:
bool init() override {
pinMode(BuiltInLed, OUTPUT);
digitalWrite(BuiltInLed, HIGH); // led off - led is wired as open drain config
}
void setBrightness(size_t channel, float brightness) override {
if (channel != 0) {
Log.error("this driver only support 1 channel, ignoring call to setBrightness for channel %d", channel);
return;
}
digitalWrite(BuiltInLed, brightness > .5f ? LOW : HIGH);
}
const LedDriverInfo * info() const override {
return &DriverInfo;
}
};
std::unique_ptr<ILedDriver> makeDummyLedDriver() {
return std::unique_ptr<ILedDriver>(new LedDriverDummy);
}
| [
"[email protected]"
] | |
ae05ec7afcfec2f2a0824122e08ba89b945947bb | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/git/gumtree/git_patch_hunk_2048.cpp | b700bdea35e6bbafb6339b41f3d998834c96904e | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 694 | cpp | status |= error("no reflog for '%s'", argv[i]);
continue;
}
recno = strtoul(spec + 2, &ep, 10);
if (*ep == '}') {
- cb.recno = -recno;
+ cb.cmd.recno = -recno;
for_each_reflog_ent(ref, count_reflog_ent, &cb);
} else {
- cb.expire_total = approxidate(spec + 2);
+ cb.cmd.expire_total = approxidate(spec + 2);
for_each_reflog_ent(ref, count_reflog_ent, &cb);
- cb.expire_total = 0;
+ cb.cmd.expire_total = 0;
}
- status |= expire_reflog(ref, sha1, 0, &cb);
+ status |= reflog_expire(ref, sha1, flags,
+ reflog_expiry_prepare,
+ should_expire_reflog_ent,
+ reflog_expiry_cleanup,
+ &cb);
free(ref);
}
return status;
}
/*
| [
"[email protected]"
] | |
f844875e7d8e9941590767a68499752faa08c19d | 71f4a843a32e1eb8caf178ded1e77ca6d8be4cee | /Interview Question/TEST100.CPP | d912de5ee649c902320ea56bd0fb8de74315eec7 | [] | no_license | suvaw/C-and-C-plus | e71a2d676ca7eb641d437bd6784b3d7abe4668d1 | ff27cfd5360e947d4be5bae2ba71ab306f612428 | refs/heads/main | 2022-12-30T01:22:11.985606 | 2020-10-04T18:47:14 | 2020-10-04T18:47:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 225 | cpp | #include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
clrscr();
char p[]="suvadipmandal";
char t;
int i,j;
for(i=0,j=strlen(p);i<j;i++)
{
t=p[i];
p[i]=p[j-i];
p[j-i]=t;
}
printf("%s",p);
getch();
} | [
"[email protected]"
] |
Subsets and Splits