ux-dx 0.2.1

use super::{Context, IndexBuffer, IndicesType};
use std::fmt;

// @short_description: Describe vertex indices stored in a #IndexBuffer.
//
// Indices allow you to avoid duplicating vertices in your vertex data
// by virtualizing your data and instead providing a sequence of index
// values that tell the GPU which data should be used for each vertex.
//
// If the GPU is given a sequence of indices it doesn't simply walk
// through each vertex of your data in order it will instead walk
// through the indices which can provide random access to the
// underlying data.
//
// Since it's very common to have duplicate vertices when describing a
// shape as a list of triangles it can often be a significant space
// saving to describe geometry using indices. Reducing the size of
// your models can make it cheaper to map them into the GPU by
// reducing the demand on memory bandwidth and may help to make better
// use of your GPUs internal vertex caching.
//
// For example, to describe a quadrilateral as 2 triangles for the GPU
// you could either provide data with 6 vertices or instead with
// indices you can provide vertex data for just 4 vertices and an
// index buffer that specfies the 6 vertices by indexing the shared
// vertices multiple times.
//
// |[
//   Vertex2f quad_vertices[] = {
//     {x0, y0}, //0 = top left
//     {x1, y1}, //1 = bottom left
//     {x2, y2}, //2 = bottom right
//     {x3, y3}, //3 = top right
//   };
//   //tell the gpu how to interpret the quad as 2 triangles...
//   unsigned char indices[] = {0, 1, 2, 0, 2, 3};
// ]|
//
// Even in the above illustration we see a saving of 10bytes for one
// quad compared to having data for 6 vertices and no indices but if
// you need to draw 100s or 1000s of quads then its really quite
// significant.
//
// Something else to consider is that often indices can be defined
// once and remain static while the vertex data may change for
// animations perhaps. That means you may be able to ignore the
// negligable cost of mapping your indices into the GPU if they don't
// ever change.
//
// The above illustration is actually a good example of static indices
// because it's really common that developers have quad mesh data that
// they need to display and we know exactly what that indices array
// needs to look like depending on the number of quads that need to be
// drawn. It doesn't matter how the quads might be animated and
// changed the indices will remain the same.  even has a utility
// (get_rectangle_indices()) to get access to re-useable indices
// for drawing quads as above.

pub struct Indices {
    // IndexBuffer *buffer;
    // size_t offset;

    // IndicesType type;

    // int immutable_ref;
}

impl Indices {
    pub fn new(
        context: &Context,
        type_: IndicesType,
        indices_data: &[u8],
        n_indices: i32,
    ) -> Indices {
        // size_t buffer_bytes = sizeof_indices_type (type) * n_indices;
        // IndexBuffer *index_buffer = index_buffer_new (context, buffer_bytes);
        // Buffer *buffer = BUFFER (index_buffer);
        // Indices *indices;
        // Error *ignore_error = NULL;

        // _buffer_set_data (buffer,
        //                        0,
        //                        indices_data,
        //                        buffer_bytes,
        //                        &ignore_error);
        // if (ignore_error)
        //   {
        //     error_free (ignore_error);
        //     object_unref (index_buffer);
        //     return NULL;
        //   }

        // indices = indices_new_for_buffer (type, index_buffer, 0);
        // object_unref (index_buffer);

        // return indices;
        unimplemented!()
    }

    pub fn new_for_buffer(type_: IndicesType, buffer: &IndexBuffer, offset: usize) -> Indices {
        // Indices *indices = g_slice_new (Indices);

        // indices->buffer = object_ref (buffer);
        // indices->offset = offset;

        // indices->type = type;

        // indices->immutable_ref = 0;

        // return _indices_object_new (indices);
        unimplemented!()
    }

    pub fn buffer(&self) -> Option<IndexBuffer> {
        // return indices->buffer;
        unimplemented!()
    }

    pub fn offset(&self) -> usize {
        // _RETURN_VAL_IF_FAIL (is_indices (indices), 0);

        // return indices->offset;
        unimplemented!()
    }

    pub fn type_(&self) -> IndicesType {
        // _RETURN_VAL_IF_FAIL (is_indices (indices),
        //                     INDICES_TYPE_UNSIGNED_BYTE);
        // return indices->type;
        unimplemented!()
    }

    pub fn set_offset(&self, offset: usize) {
        // _RETURN_IF_FAIL (is_indices (indices));

        // if (G_UNLIKELY (indices->immutable_ref))
        //     warn_about_midscene_changes ();

        // indices->offset = offset;
        unimplemented!()
    }
}

impl fmt::Display for Indices {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Indices")
    }
}