void SDLWindow::setGammaRamp(const Array<uint16>& gammaRamp) {
    alwaysAssertM(gammaRamp.size() >= 256, "Gamma ramp must have at least 256 entries");

    Log* debugLog = Log::common();

    uint16* ptr = const_cast<uint16*>(gammaRamp.getCArray());
    #ifdef WIN32
        // On windows, use the more reliable SetDeviceGammaRamp function.
        // It requires separate RGB gamma ramps.
        uint16 wptr[3 * 256];
        for (int i = 0; i < 256; ++i) {
            wptr[i] = wptr[i + 256] = wptr[i + 512] = ptr[i]; 
        }
        BOOL success = SetDeviceGammaRamp(wglGetCurrentDC(), wptr);
    #else
        bool success = (SDL_SetGammaRamp(ptr, ptr, ptr) != -1);
    #endif

    if (! success) {
        if (debugLog) {debugLog->println("Error setting gamma ramp!");}

        #ifdef WIN32
            debugAssertM(false, "Failed to set gamma ramp");
        #else
            if (debugLog) {debugLog->println(SDL_GetError());}
            debugAssertM(false, SDL_GetError());
        #endif
    }
}

ColorRGB
ColorRGB::fromHSV(Vector3 const & hsv)
{
  debugAssertM((hsv[0] <= 1.0f && hsv[0] >= 0.0f)
            && (hsv[1] <= 1.0f && hsv[1] >= 0.0f)
            && (hsv[2] <= 1.0f && hsv[2] >= 0.0f), "ColorRGB: H, S, V must be in [0, 1]");

  int const i = std::min(5, (int)std::floor(6.0 * hsv[0]));
  Real const f = 6.0f * hsv[0] - i;
  Real const m = hsv[2] * (1.0f - (hsv[1]));
  Real const n = hsv[2] * (1.0f - (hsv[1] * f));
  Real const k = hsv[2] * (1.0f - (hsv[1] * (1 - f)));

  switch (i)
  {
    case 0: return ColorRGB(hsv[2], k, m);
    case 1: return ColorRGB(n, hsv[2], m);
    case 2: return ColorRGB(m, hsv[2], k);
    case 3: return ColorRGB(m, n, hsv[2]);
    case 4: return ColorRGB(k, m, hsv[2]);
    case 5: return ColorRGB(hsv[2], m, n);

    default: debugAssertM(false, "ColorRGB: Fell through switch when attempting conversion from HSV");
  }

  return ColorRGB::black();
}

	Any::Data::~Data() {
		debugAssertM(referenceCount.value() <= 0, "Deleted while still referenced.");

		// Destruct but do not deallocate children
		switch (type) {
		case STRING:
			debugAssert(value.s != NULL);
			value.s->~basic_string();
			break;

		case ARRAY:
			debugAssert(value.a != NULL);
			value.a->~Array();
			break;

		case TABLE:
			debugAssert(value.t != NULL);
			value.t->~Table();
			break;

		default:
			// All other types should have a NULL value pointer (i.e., they were used just for name and comment fields)
			debugAssertM(value.s == NULL, "Corrupt Any::Data::Value");
		}

		value.s = NULL;
	}

bool
BinaryOutputStream::_commit(bool flush, bool force)
{
  // If there is already an error, the commit fails
  if (!m_ok)
    return false;

  // Nothing to commit for memory streams
  if (m_path == "<memory>")
    return true;

  // Is there anything new to write?
  if (!force && m_bufferLen <= 0)
    return true;

  debugAssertM(m_beginEndBits == 0, getNameStr() + ": Missing endBits before commit");

//   // Make sure the directory exists
//   std::string dir = FilePath::parent(m_path);
//   if (!FileSystem::exists(dir))
//     if (!FileSystem::createDirectory(dir))
//     {
//       DGP_ERROR << "BinaryOutputStream: Could not create parent directory of '" << m_path << "'";
//       m_ok = false;
//     }

  FILE * file = NULL;
  if (m_ok)
  {
    char const * mode = (m_alreadyWritten > 0 ? "ab" : "wb");
    file = fopen(m_path.c_str(), mode);
    if (!file)
    {
      DGP_ERROR << "BinaryOutputStream: Could not open file '" << m_path << "' for writing";
      m_ok = false;
    }
  }

  if (m_ok)
  {
    if (m_buffer != NULL && m_bufferLen > 0)
    {
      size_t success = fwrite(m_buffer, (size_t)m_bufferLen, 1, file);
      debugAssertM(success == 1, getNameStr() + ": Could not write buffer contents to disk");
      (void)success;

      m_alreadyWritten += m_bufferLen;
      m_bufferLen = 0;
      m_pos = 0;
    }

    if (flush)
      fflush(file);

    fclose(file);
    file = NULL;
  }

  return m_ok;
}

Radiance3 RayTracer::L_direct(const shared_ptr<Surfel>& surfel, const Vector3& wo, ThreadData& threadData) const {
    Radiance3 L;
    const Point3& X(surfel->position);
    const Vector3& n(surfel->shadingNormal);

    for (int i = 0; i < m_lighting.lightArray.size(); ++i) {
        const shared_ptr<Light> light(m_lighting.lightArray[i]);

        if (light->producesDirectIllumination()) {

            const Point3&  Y(light->frame().translation);
            const Vector3& wi((Y - X).direction());

            debugAssertM(X.isFinite(), "The surface is not at a finite location");
            debugAssertM(Y.isFinite(), "The light is not at a finite location");

            if ((! light->castsShadows()) || visible(Y, X, true)) {
                const Color3&      f(surfel->finiteScatteringDensity(wi, wo));
                const Biradiance3& B(light->biradiance(X));

                L += f * B * abs(wi.dot(n));
                debugAssertM(L.isFinite(), "Non-finite radiance in L_direct");
            }
        }
    }

    return L;
}

// The following are called by the VARSystem.
void VAR::vertexPointer() const {
	debugAssert(valid());
	glEnableClientState(GL_VERTEX_ARRAY);
    debugAssertM(underlyingRepresentation != GL_UNSIGNED_INT, 
              "OpenGL does not support GL_UNSIGNED_INT as a vertex format.");
    debugAssertM(underlyingRepresentation != GL_UNSIGNED_SHORT, 
              "OpenGL does not support GL_UNSIGNED_SHORT as a vertex format.");
    debugAssertM(underlyingRepresentation != GL_UNSIGNED_BYTE, 
              "OpenGL does not support GL_UNSIGNED_BYTE as a vertex format.");
	glVertexPointer(elementSize / sizeOfGLFormat(underlyingRepresentation), 
                    underlyingRepresentation, elementSize, _pointer);
}

void VAR::set(int index, const void* value, GLenum glformat, size_t eltSize) {
    (void)glformat;
    debugAssertM(index < numElements && index >= 0, 
        "Cannot call VAR::set with out of bounds index");
    
    debugAssertM(glformat == underlyingRepresentation, 
        "Value argument to VAR::set must match the intialization type.");

    debugAssertM(eltSize == elementSize, 
        "Value argument to VAR::set must match the intialization type's memory footprint.");

    uploadToCard(value, index * eltSize, eltSize);
}

void ReliableConduit::receiveIntoBuffer() {

    debugAssert(state == RECEIVING);
    debugAssert(messageType != 0);
    debugAssertM(receiveBufferUsedSize < messageSize, "Message already received.");
    debugAssertM(messageSize >= receiveBufferUsedSize, "Message size overflow.");

    // Read the data itself
    int ret = 0;
    uint32 left = messageSize - receiveBufferUsedSize;
    int count = 0;
    while ((ret != SOCKET_ERROR) && (left > 0) && (count < 10)) {

        ret = recv(sock, ((char*)receiveBuffer) + receiveBufferUsedSize, left, 0);

        if (ret > 0) {
            left -= ret;
            receiveBufferUsedSize += ret;
            bReceived += ret;

            if (left > 0) {
                // There's still more. Give the machine a chance to read
                // more data, but don't wait forever.

                ++count;
                System::sleep(0.001);
            }
        } else {
            // Something went wrong
            break;
        }
    }

    if ((ret == 0) || (ret == SOCKET_ERROR)) {

        if (nd->debugLog) {
            if (ret == SOCKET_ERROR) {
                nd->debugLog->printf("Call to recv failed.  ret = %d,"
                     " sizeof(messageSize) = %d\n", ret, messageSize);
                nd->debugLog->println(socketErrorCode());
            } else {
                nd->debugLog->printf("recv returned 0\n");
            }
        }
        nd->closesocket(sock);
        return;
    }

    ++mReceived;
}

bool RegistryUtil::writeString(const std::string& key, const std::string& value, const std::string& data) {
    size_t pos = key.find('\\', 0);
    if (pos == std::string::npos) {
        return false;
    }

    HKEY hkey = getRootKeyFromString(key.c_str(), pos);

    if (hkey == NULL) {
        return false;
    }

    HKEY openKey;
    int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey);
    debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);

    if (result == ERROR_SUCCESS) {
        alwaysAssertM(data.size() < 0xFFFFFFFE, "String too long");
        result = RegSetValueExA(openKey, value.c_str(), 0, REG_SZ, reinterpret_cast<const BYTE*>(data.c_str()), (int)(data.size() + 1));                
        debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value.");

        RegCloseKey(openKey);
    }
    return (result == ERROR_SUCCESS);
}

void Image3unorm8::load(const String& filename) {
    shared_ptr<Image> image = Image::fromFile(filename);
    if (image->format() != ImageFormat::RGB8()) {
        image->convertToRGB8();
    }

    switch (image->format()->code)
    {
        case ImageFormat::CODE_L8:
            copyArray(static_cast<const Color1unorm8*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        case ImageFormat::CODE_L32F:
            copyArray(static_cast<const Color1*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        case ImageFormat::CODE_RGB8:
            copyArray(static_cast<const Color3unorm8*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        case ImageFormat::CODE_RGB32F:
            copyArray(static_cast<const Color3*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        case ImageFormat::CODE_RGBA8:
            copyArray(static_cast<const Color4unorm8*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        case ImageFormat::CODE_RGBA32F:
            copyArray(static_cast<const Color4*>(image->toPixelTransferBuffer()->buffer()), image->width(), image->height());
            break;
        default:
            debugAssertM(false, "Trying to load unsupported image format");
            break;
    }

    setChanged(true);
}

Radiance3 RayTracer::L_scatteredSpecularIndirect(const shared_ptr<Surfel>& surfel, const Vector3& wo, int bouncesLeft, Random& rnd) const{
    Radiance3 L(0,0,0);
    if (bouncesLeft > 0){
        G3D::UniversalSurfel::ImpulseArray impulses;

        //Downcast to universalSurfel to allow getting impulses
        const shared_ptr<UniversalSurfel>& u = dynamic_pointer_cast<UniversalSurfel>(surfel);
        debugAssertM(notNull(u), "Encountered a Surfel that was not a UniversalSurfel");
        
        //Find the impulses on the surface
        u->getImpulses(PathDirection::EYE_TO_SOURCE, wo, impulses);

        //For each impulses, recursively computed the radiance from that direction
        for (int i = 0; i < impulses.size(); ++i){
            Vector3 wi = impulses[i].direction;
            Color3 magnitude = impulses[i].magnitude;
            ++m_stats->indirectRays;
            L += L_i(surfel->position, wi, bouncesLeft - 1, rnd) * magnitude;
        }
        
        //If we enable path tracing, also cast a random ray from the surfel
        //Technically it is not SpecularIndirect. But as it is not used often, I'm going to leave it here
        if (m_settings.enablePathTracing){
            Vector3 wi = Vector3::hemiRandom(surfel->shadingNormal, rnd);
            L += L_i(surfel->position, wi, bouncesLeft - 1, rnd) * surfel->finiteScatteringDensity(wi,wo) * abs(wi.dot(surfel->shadingNormal));
        }
    }
    return L;
}

ParticleSystemModel::Emitter::Emitter(const Specification& s) : m_specification(s) {
    switch (s.shapeType) {
    case Shape::Type::MESH:
        // Load the mesh
        debugAssertM(false, "TODO");
        break;

    case Shape::Type::BOX:
        m_spawnShape = shared_ptr<Shape>(new BoxShape(s.box));
        break;

    case Shape::Type::CYLINDER:
        m_spawnShape = shared_ptr<Shape>(new CylinderShape(s.cylinder));
        break;

    case Shape::Type::SPHERE:
        m_spawnShape = shared_ptr<Shape>(new SphereShape(s.sphere));
        break;

    default:
        alwaysAssertM(false, "Illegal spawn shape");
    }

    m_material = ParticleMaterial::create(s.material);
}

ReferenceCountedObject::ReferenceCountedObject() : 
    ReferenceCountedObject_refCount(0), 
    ReferenceCountedObject_weakPointer(0) {

    debugAssertM(isValidHeapPointer(this), 
        "Reference counted objects must be allocated on the heap.");
}

void VAR::update(
    const void*         sourcePtr,
    int                 _numElements,
    GLenum              glformat,
    size_t              eltSize) {

	size_t size = eltSize * _numElements;

    alwaysAssertM(size <= _maxSize,
        "A VAR can only be updated with an array that is smaller "
        "or equal size (in bytes) to the original array.");

    alwaysAssertM(generation == area->currentGeneration(),
        "The VARArea has been reset since this VAR was created.");

	numElements              = _numElements;
    underlyingRepresentation = glformat;
	elementSize              = eltSize;

    debugAssertM(
        (elementSize % sizeOfGLFormat(underlyingRepresentation)) == 0,
        "Sanity check failed on OpenGL data format; you may"
        " be using an unsupported type in a vertex array.");
	
	// Upload the data
    if (size > 0) {
        uploadToCard(sourcePtr, 0, size);
    }
}

shared_ptr<TileSheet> TileSheet::create(const Any& any) {
	shared_ptr<TileSheet> tileSheet(new TileSheet());

	AnyTableReader r(any);

	Any legend;
	r.getIfPresent("legend", legend);
	for (Table<String, Any>::Iterator it = legend.table().begin(); it.hasMore(); ++it) {
		const String& mapLabel = it.key();
        const shared_ptr<Tile>& tile = Tile::create(mapLabel, it.value());

		// TODO: Switch to report
		debugAssertM(! tileSheet->m_tileByID.containsKey(tile->id()), "Duplicate tile ID");

		tileSheet->m_tileByID.set(tile->id(), tile);
		tileSheet->m_tileByMapLabel.set(tile->mapLabel(), tile);
	}

    r.getFilenameIfPresent("color", tileSheet->m_colorFilename);
    r.getFilenameIfPresent("blueprint", tileSheet->m_blueprintFilename);

    // Even though we lazy load these (since the server can't load graphics),
    // we check immediately to ensure that the files exist
    if (! FileSystem::exists(tileSheet->m_colorFilename)) {
        report("File not found: \"" + tileSheet->m_colorFilename + "\".", ReportLevel::ERROR);
    }

    if (! FileSystem::exists(tileSheet->m_blueprintFilename)) {
        report("File not found: \"" + tileSheet->m_blueprintFilename + "\".", ReportLevel::ERROR);
    }

	r.verifyDone();

	return tileSheet;
}

Matrix4float64 Matrix4float64::perspectiveProjection(
    double            left,
    double            right,
    double            bottom,
    double            top,
    double            nearval,
    double            farval,
    float             upDirection) {
    double x, y, a, b, c, d;

    x = (2.0*nearval) / (right-left);
    y = (2.0*nearval) / (top-bottom);
    a = (right+left) / (right-left);
    b = (top+bottom) / (top-bottom);

    if (farval >= inf()) {
       // Infinite view frustum
       c = -1.0;
       d = -2.0 * nearval;
    } else {
       c = -(farval+nearval) / (farval-nearval);
       d = -(2.0*farval*nearval) / (farval-nearval);
    }

    debugAssertM(abs(upDirection) == 1.0, "upDirection must be -1 or +1");
    y *= upDirection;
    b *= upDirection;

    return Matrix4float64(
        (float)x,  0,  (float)a,  0,
        0,  (float)y,  (float)b,  0,
        0,  0,  (float)c,  (float)d,
        0,  0, -1,  0);
}

bool RegistryUtil::writeBytes(const std::string& key, const std::string& value, const uint8* data, uint32 dataSize) {
    debugAssert(data);

    size_t pos = key.find('\\', 0);
    if (pos == std::string::npos) {
        return false;
    }

    HKEY hkey = getRootKeyFromString(key.c_str(), pos);

    if (hkey == NULL) {
        return false;
    }

    HKEY openKey;
    int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey);
    debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);

    if (result == ERROR_SUCCESS) {
        if (data) {
            result = RegSetValueExA(openKey, value.c_str(), 0, REG_BINARY, reinterpret_cast<const BYTE*>(data), dataSize);
        }

        debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value.");

        RegCloseKey(openKey);
    }
    return (result == ERROR_SUCCESS);
}

/** True if the next token begins the close tag */
static bool atClose(TextInput& t, const std::string name) {
    if ((t.peek().type() == Token::SYMBOL) && (t.peek().string() == "<")) {
        // Need to keep looking ahead
        Token p0 = t.read();
        if ((t.peek().type() == Token::SYMBOL) && (t.peek().string() == "/")) {
            // Check the name on the close tag.  It *must* match if
            // this is a well-formed document, but there might be a
            // tag error.
            Token p1 = t.read();
            Token p2 = t.peek();
            std::string s = p2.string();
            debugAssertM(beginsWith(name, s), "Mismatched close tag");

            // Put the tokens back
            t.push(p1);
            t.push(p0);
            return true;
        } else {
            // Put the read token back
            t.push(p0);
            return false;
        }
    } else {
        return false;
    }
}

bool RegistryUtil::writeInt32(const String& key, const String& value, int32 data) {
    size_t pos = key.find('\\', 0);
    if (pos == String::npos) {
        return false;
    }

    HKEY hkey = getRootKeyFromString(key.c_str(), pos);

    if (hkey == NULL) {
        return false;
    }

    HKEY openKey;
    int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey);
    debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);

    if (result == ERROR_SUCCESS) {
        result = RegSetValueExA(openKey, value.c_str(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&data), sizeof(int32));

        debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value.");

        RegCloseKey(openKey);
    }
    return (result == ERROR_SUCCESS);
}

void Entity::init
   (const std::string&          name,
    Scene*                      scene,
    const CFrame&               frame,
    const shared_ptr<Track>&    track,
    bool                        canChange,
    bool                        shouldBeSaved) {

    m_name          = name;
    m_canChange     = canChange;
    m_shouldBeSaved = shouldBeSaved;
    m_track         = track;
    m_scene         = scene;

    if (notNull(track)) {
        m_previousFrame = m_frame = m_track->computeFrame(0);
    } else {
        m_frame = m_previousFrame = frame;
    }
    
    m_lastChangeTime = System::time();
    if (! m_canChange && notNull(m_track)) {
        debugAssertM(false, "Track specified for an Entity that cannot change.");
    }
}