示例#1
0
        /**
         * @fn  void palette_t::update_adjusted_color(UINT32 group, UINT32 index)
         *
         * @brief   -------------------------------------------------
         *            update_adjusted_color - update a color index by group and index pair
         *          -------------------------------------------------.
         *
         * @param   group   The group.
         * @param   index   Zero-based index of the.
         */
        void update_adjusted_color(uint32_t group, uint32_t index)
        {
            // compute the adjusted value
            rgb_t adjusted = adjust_palette_entry(m_entry_color[index],
                                                  m_group_bright[group] + m_brightness,
                                                  m_group_contrast[group] * m_entry_contrast[index] * m_contrast,
                                                  m_gamma_map);

            // if not different, ignore
            uint32_t finalindex = group * m_numcolors + index;

            if (m_adjusted_color[finalindex] == adjusted)
            {
                return;
            }

            // otherwise, modify the adjusted color array
            m_adjusted_color[finalindex] = adjusted;
            m_adjusted_rgb15[finalindex] = adjusted.as_rgb15();

            // mark dirty in all clients
            for (palette_client client = m_client_list; client != null; client = client.next())
            {
                client.mark_dirty(finalindex);
            }
        }
示例#2
0
        // construction/destruction
        //-------------------------------------------------
        //  palette_t - constructor
        //-------------------------------------------------
        palette_t(uint32_t numcolors, uint32_t numgroups = 1)
        {
            m_refcount       = 1;
            m_numcolors      = numcolors;
            m_numgroups      = numgroups;
            m_brightness     = 0.0f;
            m_contrast       = 1.0f;
            m_gamma          = 1.0f;
            m_entry_color    = new std.vector <rgb_t>((int)numcolors);
            m_entry_contrast = new std.vector <float>((int)numcolors);
            m_adjusted_color = new std.vector <rgb_t>((int)(numcolors * numgroups + 2));
            m_adjusted_rgb15 = new std.vector <rgb15_t>((int)(numcolors * numgroups + 2));
            m_group_bright   = new std.vector <float>((int)numgroups);
            m_group_contrast = new std.vector <float>((int)numgroups);
            m_client_list    = null;


            // initialize gamma map
            for (uint32_t index = 0; index < 256; index++)
            {
                m_gamma_map[index] = (uint8_t)index;
            }

            // initialize the per-entry data
            for (uint32_t index = 0; index < numcolors; index++)
            {
                m_entry_color[index]    = rgb_t.black();
                m_entry_contrast[index] = 1.0f;
            }

            // initialize the per-group data
            for (uint32_t index = 0; index < numgroups; index++)
            {
                m_group_bright[index]   = 0.0f;
                m_group_contrast[index] = 1.0f;
            }

            // initialize the expanded data
            for (uint32_t index = 0; index < numcolors * numgroups; index++)
            {
                m_adjusted_color[index] = rgb_t.black();
                m_adjusted_rgb15[index] = rgb_t.black().as_rgb15();
            }

            // add black and white as the last two colors
            m_adjusted_color[numcolors * numgroups + 0] = rgb_t.black();
            m_adjusted_rgb15[numcolors * numgroups + 0] = rgb_t.black().as_rgb15();
            m_adjusted_color[numcolors * numgroups + 1] = rgb_t.white();
            m_adjusted_rgb15[numcolors * numgroups + 1] = rgb_t.white().as_rgb15();
        }
示例#3
0
        dirty_state [] m_dirty = new dirty_state[2]; // two dirty states


        // construction/destruction
        //-------------------------------------------------
        //  palette_client - constructor
        //-------------------------------------------------
        public palette_client(palette_t palette)
        {
            m_palette     = palette;
            m_next        = null;
            m_liveIdx     = 0; // m_live(&m_dirty[0]),
            m_previousIdx = 1; // m_previous(&m_dirty[1])


            // add a reference to the palette
            palette.ref_();


            // resize the dirty lists
            uint32_t total_colors = (uint32_t)(palette.num_colors() * palette.num_groups());

            m_dirty[0] = new dirty_state();
            m_dirty[1] = new dirty_state();
            m_dirty[0].resize(total_colors);
            m_dirty[1].resize(total_colors);

            // now add us to the list of clients
            m_next = palette.m_client_list;
            palette.m_client_list = this;
        }