Jeu Videz votre presse-papier - Page 1158

    template <typename T>
    void Storage<T>::CopyToMemory(std::uint32_t index, std::uint8_t const* data)
    {
        static_assert(alignof(T) == 1, "Structures passed to Storage<T, ...> must be aligned to 1 byte. Use #pragma pack(push, 1)!");

        std::uint32_t memoryOffset = 0;
        std::uint8_t* structure_ptr = reinterpret_cast<std::uint8_t*>(&get_storage()[index]);
        for (std::uint32_t j = 0; j < meta_t::field_count; ++j)
        {
            std::uint8_t* memberTarget = structure_ptr + memoryOffset;
            BOOST_ASSERT(reinterpret_cast<std::uintptr_t>(memberTarget) < reinterpret_cast<std::uintptr_t>(structure_ptr + sizeof(T)));

            auto array_size = meta_t::field_sizes[j];
            auto memory_size_item = 4u;
            switch (meta_t::field_types[j])
            {
                case 's':
                case 'i':
                case 'n':
                case 'u':
                case 'f':
                    break;
                case 'l':
                    memory_size_item = 8u;
                    break;
                case 'b':
                    memory_size_item = 1u;
                    break;
                default:
                    BOOST_ASSERT(false);
            }

            array_size /= memory_size_item;

            if (meta_t::field_types[j] == 's')
            {
                for (std::uint32_t i = 0; i < array_size; ++i)
                {
                    auto stringTableOffset = *reinterpret_cast<std::uint32_t const*>(data + meta_t::field_offsets[j] + 4u * i);
                    const char* stringValue = reinterpret_cast<const char*>(&get_string_table()[stringTableOffset]);
                    *reinterpret_cast<std::uintptr_t*>(memberTarget) = reinterpret_cast<std::uintptr_t>(stringValue);

                    memoryOffset += sizeof(std::uintptr_t); // // Advance to the next member ...
                    memberTarget += sizeof(std::uintptr_t); // ... But also advance our own pointer in case we are an array.
                }
            }
            else
            {
                if (memory_size_item > meta_t::field_sizes[j])
                {
                    for (std::uint32_t i = 0; i < array_size; ++i)
                    {
                        memcpy(memberTarget, data + meta_t::field_offsets[j] + i * memory_size_item, memory_size_item);
                        constexpr static const std::uint32_t masks[] = { 0x000000FFu, 0x0000FFFFu, 0x00FFFFFFu, 0xFFFFFFFFu };
                        *reinterpret_cast<std::uint32_t*>(memberTarget) &= masks[meta_t::field_sizes[j] - 1];

                        memoryOffset += memory_size_item;
                        memberTarget += memory_size_item;
                    }
                }
                else
                {
                    memcpy(memberTarget, data + meta_t::field_offsets[j], meta_t::field_sizes[j]);
                    memoryOffset += meta_t::field_sizes[j];
                }
            }
        }
    }

#pragma once

#include "C3Vector.hpp"
#include "CAaBox.hpp"

#include <cmath>

namespace wowgm::game::geometry
{
    namespace VolumeIntersections
    {
        using namespace wowgm::game::structures;

        static bool boxContainsPoint(CAaBox const& box, C3Vector const& position)
        {
            for (std::uint32_t i = 0; i < 3; ++i)
            {
                if (box.Maximum[i] < position[i])
                    return false;

                if (box.Minimum[i] > position[i])
                    return false;
            }

            return true;
        }

        static bool sphereContainsPoint(C3Vector const& sphereCenter, double sphereRadius, C3Vector const& position)
        {
            return (sphereCenter.distanceSquared(position) <= (sphereRadius * sphereRadius));
        }

        static bool sphereContainsBox(C3Vector const& sphereCenter, double sphereRadius, CAaBox const& boundingBox)
        {
            return sphereContainsPoint(sphereCenter, sphereRadius, boundingBox.Minimum)
                && sphereContainsPoint(sphereCenter, sphereRadius, boundingBox.Maximum);
        }

        static bool boxContainsBox(CAaBox const& box, CAaBox const& otherBox)
        {
            return boxContainsPoint(box, otherBox.Maximum)
                && boxContainsPoint(box, otherBox.Minimum);
        }

        static bool boxContainsSphere(CAaBox const& box, C3Vector const& sphereCenter, double sphereRadius)
        {
            C3Vector topCasingCorner;
            topCasingCorner.X = sphereCenter.X + sphereRadius;
            topCasingCorner.Y = sphereCenter.Y + sphereRadius;
            topCasingCorner.Z = sphereCenter.Z + sphereRadius;

            if (!boxContainsPoint(box, topCasingCorner))
                return false;

            C3Vector lessCasingCorner;
            lessCasingCorner.X = sphereCenter.X - sphereRadius;
            lessCasingCorner.Y = sphereCenter.Y - sphereRadius;
            lessCasingCorner.Z = sphereCenter.Z - sphereRadius;

            if (!boxContainsPoint(box, lessCasingCorner))
                return false;

            return true;
        }

        /// This only checks for intersections, not inclusions!
        static bool boxIntersectsSphere(CAaBox const& box, C3Vector sphereCenter, double sphereRadius)
        {

        }
    }
}

For making ramen noodle, I made wooden noodle maker tool that my husband made by cardboard !

Husband - ramen cook
Me - DIY maker pic.twitter.com/aYu3QC5zzx

— Nao Kondo?Robot Artist! (@nao70kondo) August 20, 2018

Session..........: diverock
Status...........: Aborted (Checkpoint)
Hash.Type........: md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5)
Hash.Target......: $1$OgGQs/Y7$75davjiRnARopovV4vc2f.
Time.Started.....: Tue Aug 21 01:04:34 2018 (12 hours, 17 mins)
Time.Estimated...: Tue Aug 28 07:26:42 2018 (6 days, 18 hours)
Guess.Base.......: File (./dictionaries/rockyou.txt)
Guess.Mod........: Rules (.\rules\dive.rule)
Guess.Queue......: 1/1 (100.00%)
Speed.Dev.#3.....:  1845.6 kH/s (76.82ms) @ Accel:1024 Loops:1000 Thr:32 Vec:1
Recovered........: 0/1 (0.00%) Digests, 0/1 (0.00%) Salts
Progress.........: 344521922914/1421327732110 (24.24%)
Rejected.........: 1961110112/344521922914 (0.57%)
Restore.Point....: 3476999/14344385 (24.24%)
Candidates.#3....: te8evonte8evon -> su8pemsuwdasu8pemsuwda
HWMon.Dev.#3.....: Temp: 73c Util: 98% Core:1708MHz Mem:3504MHz Bus:16

Keypad to unlock a building, as seen in Israel, a country founded in 1948.

What do you think the code is?

(Multiple security #FAILS depicted in one photo...)#CyberSecurity #InfoSec #Privacy #FAIL #Funny #meme #Israel #Security #password #technology #wisdom #life #tech #photo pic.twitter.com/tZ5Bn9I10F

— Joseph Steinberg (@JosephSteinberg) August 6, 2018