Beispiel #1
0
void
lcpp::LispRuntimeState::shutdown()
{
    EZ_ASSERT(m_stats.m_initializationCount > 0,
              "LCPP_pRuntime was never initialized.");
    EZ_ASSERT(m_stats.m_initializationCount > m_stats.m_shutdownCount,
              "The LCPP_pRuntime was not shut down often enough!");

    ++m_stats.m_shutdownCount;

    m_pGC->removeRoot(m_pReaderState->m_pMacroEnv.get());
    m_pGC->removeRoot(m_pGlobalEnvironment);
    m_pGC->removeRoot(m_pSyntaxEnvironment);

    m_pReaderState->m_pMacroEnv = nullptr;
    EZ_DELETE(defaultAllocator(), m_pReaderState);
    m_pPrinterState->m_pOutStream = nullptr;
    EZ_DELETE(defaultAllocator(), m_pPrinterState);
    m_pGlobalEnvironment = nullptr;
    m_pSyntaxEnvironment = nullptr;

    // TODO Once we have a per-runtime garbage collector system running, uncomment the following line.
    //m_pGC->clear();
    m_pGC->collect(0);
}
Beispiel #2
0
ShaderProgram::ShaderProgram()
: handle{0}
, isLinked{false}
, errorLog{}

, m_attribLocations{defaultAllocator()}
, m_uniformLocations{defaultAllocator()}

{
}
VectorType
NativeArrayToMappedVector(Datum inDatum, bool inNeedMutableClone) {
    typedef typename VectorType::Scalar Scalar;

    ArrayType* array = reinterpret_cast<ArrayType*>(
        madlib_DatumGetArrayTypeP(inDatum));
    size_t arraySize = ARR_NDIM(array) == 1
        ? ARR_DIMS(array)[0]
        : ARR_DIMS(array)[0] * ARR_DIMS(array)[1];

    if (!(ARR_NDIM(array) == 1
        || (ARR_NDIM(array) == 2
            && (ARR_DIMS(array)[0] == 1 || ARR_DIMS(array)[1] == 1)))) {

        std::stringstream errorMsg;
        errorMsg << "Invalid type conversion to matrix. Expected one-"
            "dimensional array but got " << ARR_NDIM(array)
            << " dimensions.";
        throw std::invalid_argument(errorMsg.str());
    }
    
    Scalar* origData = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
    Scalar* data;

    if (inNeedMutableClone) {
        data = reinterpret_cast<Scalar*>(
            defaultAllocator().allocate<dbal::FunctionContext, dbal::DoNotZero,
                dbal::ThrowBadAlloc>(sizeof(Scalar) * arraySize));
        std::copy(origData, origData + arraySize, data);
    } else {
        data = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
    }
    
    return VectorType(data, arraySize);
}
Beispiel #4
0
b32 ShaderProgram::attachShaderFromMemory(ShaderType type,
                                          const String& shaderSource)
{
	if (!handle)
		handle = glCreateProgram();

	u32 shader = 0;
	if (type == ShaderType::Vertex)
		shader = glCreateShader(GL_VERTEX_SHADER);
	else if (type == ShaderType::Fragment)
		shader = glCreateShader(GL_FRAGMENT_SHADER);
	else
		panic("Unknown shader type.");

	const char* cStrSource = cString(shaderSource);
	glShaderSource(shader, 1, &cStrSource, nullptr);
	glCompileShader(shader);

	s32 status;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
	if (status == false)
	{
		String msg;
		if (type == ShaderType::Vertex)
			msg = "Compile failure in vertex shader: \n";
		else if (type == ShaderType::Fragment)
			msg = "Compile failure in fragment shader: \n";
		else
			panic("Unknown shader type.");

		s32 infoLogLength;
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);

		Allocator& a = defaultAllocator();

		char* strInfoLog =
		    (char*)a.allocate((infoLogLength + 1) * sizeof(char));
		defer(a.deallocate(strInfoLog));

		glGetShaderInfoLog(shader, infoLogLength, nullptr, strInfoLog);

		append(msg, strInfoLog);
		append(msg, '\n');

		append(errorLog, msg);

		glDeleteShader(shader);

		return false;
	}

	glAttachShader(handle, shader);

	return true;
}
Beispiel #5
0
void
lcpp::LispRuntimeState::initialize(ezAllocatorBase* pAllocator)
{
    EZ_ASSERT(m_stats.m_shutdownCount <= m_stats.m_initializationCount,
              "LCPP_pRuntime was shut down more often than it was initialized!");

    if (m_stats.m_shutdownCount < m_stats.m_initializationCount)
    {
        shutdown();
    }

    EZ_ASSERT(m_stats.m_initializationCount == m_stats.m_shutdownCount,
              "LCPP_pRuntime initialization and shutdown count must be balanced!");

    ++m_stats.m_initializationCount;

    m_pAllocator = pAllocator ? pAllocator : defaultAllocator();
    m_pGC = lcpp::getGarbageCollector();

#if EZ_ENABLED(EZ_COMPILE_FOR_DEBUG)
    g_pGC = m_pGC.get();
#endif

    m_pSyntaxEnvironment = env::createTopLevel(symbol::create("syntax")).get();
    m_pGC->addRoot(m_pSyntaxEnvironment);
    m_pGlobalEnvironment = env::create(getSyntaxEnvironment(), symbol::create("global")).get();
    m_pGC->addRoot(m_pGlobalEnvironment);

    //////////////////////////////////////////////////////////////////////////

    m_pReaderState = EZ_NEW(defaultAllocator(), reader::State);
    m_pReaderState->m_pMacroEnv = env::createTopLevel(symbol::create("reader-macros"));
    m_pGC->addRoot(m_pReaderState->m_pMacroEnv.get());

    m_pPrinterState = EZ_NEW(defaultAllocator(), printer::State);

    //////////////////////////////////////////////////////////////////////////

    registerBuiltIns();
}
ArrayType*
VectorToNativeArray(const Eigen::MatrixBase<Derived>& inVector) {
    typedef typename Derived::Scalar T;
    typedef typename Derived::Index Index;

    MutableArrayHandle<T> arrayHandle
        = defaultAllocator().allocateArray<T>(inVector.size());

    T* ptr = arrayHandle.ptr();
    for (Index el = 0; el < inVector.size(); ++el)
        *(ptr++) = inVector(el);

    return arrayHandle.array();
}
ArrayType*
MatrixToNativeArray(const Eigen::MatrixBase<Derived>& inMatrix) {
    typedef typename Derived::Scalar T;
    typedef typename Derived::Index Index;

    MutableArrayHandle<T> arrayHandle
        = defaultAllocator().allocateArray<T>(
            inMatrix.cols(), inMatrix.rows());

    T* ptr = arrayHandle.ptr();
    for (Index row = 0; row < inMatrix.rows(); ++row)
        for (Index col = 0; col < inMatrix.cols(); ++col)
            *(ptr++) = inMatrix(row, col);

    return arrayHandle.array();
}
Beispiel #8
0
b32 ShaderProgram::link()
{
	if (!handle)
		handle = glCreateProgram();

	if (!isLinked)
	{
		glLinkProgram(handle);

		s32 status;
		glGetProgramiv(handle, GL_LINK_STATUS, &status);
		if (!status)
		{
			String msg{"ShaderProgram linking failure: \n"};

			s32 infoLogLength;
			glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &infoLogLength);

			Allocator& a = defaultAllocator();

			char* strInfoLog =
			    (char*)a.allocate((infoLogLength + 1) * sizeof(char));
			defer(a.deallocate(strInfoLog));

			glGetProgramInfoLog(handle, infoLogLength, nullptr, strInfoLog);

			append(msg, strInfoLog);
			append(msg, "\n");
			append(errorLog, msg);

			glDeleteProgram(handle);
			handle = 0;
			isLinked = false;

			return isLinked;
		}

		isLinked = true;
	}

	return isLinked;
}
void
ByteStreamHandleBuf<Storage, CharType, Mutable>::resize(
    size_t inSize, size_t inPivot) {

    if (inSize == this->size())
        return;

    char_type* oldPtr = this->ptr();
    size_t secondChunkStart
        = inPivot > this->size() ? this->size() : inPivot;
    size_t oldSize = this->size();
    ptrdiff_t delta = inSize - oldSize;

    // FIXME: Deallocate old memory!
    this->mStorage = defaultAllocator().allocateByteString<
        dbal::FunctionContext, dbal::DoZero, dbal::ThrowBadAlloc>(inSize);

    std::copy(oldPtr, oldPtr + secondChunkStart, this->ptr());
    std::copy(oldPtr + secondChunkStart, oldPtr + oldSize,
        this->ptr() + secondChunkStart + delta);
    std::fill(this->ptr() + secondChunkStart,
        this->ptr() + secondChunkStart + delta, 0);
}
Beispiel #10
0
const Array<VideoMode>& VideoMode::getFullscreenModes()
{
	LOCAL_PERSIST Array<VideoMode> modes{defaultAllocator()};

	if (len(modes) == 0)
	{
		s32 displayModeCount;
		SDL_DisplayMode dm;

		displayModeCount = SDL_GetNumDisplayModes(0);

		if (displayModeCount < 1)
		{
			std::cerr << "SDL_GetNumDisplayModes failed: " << SDL_GetError()
			          << std::endl;
			return modes;
		}

		for (s32 i = 0; i < displayModeCount; i++)
		{
			if (SDL_GetDisplayMode(0, i, &dm) != 0)
			{
				std::cerr << "SDL_GetNumDisplayModes failed: " << SDL_GetError()
				          << std::endl;
				continue;
			}
			append(
			    modes,
			    VideoMode{(u32)dm.w, (u32)dm.h, SDL_BITSPERPIXEL(dm.format)});
		}

		std::sort(begin(modes), end(modes), std::greater<VideoMode>());
	}

	return modes;
}
Beispiel #11
0
bool createGBuffer(GBuffer& b, u32 w, u32 h)
{
	if (w == b.width && h == b.height) // GBuffer already exists
		return true;

	b.width  = w;
	b.height = h;

	glGenFramebuffers(1, &b.fbo);

	glBindFramebuffer(GL_FRAMEBUFFER, b.fbo);
	defer(glBindFramebuffer(GL_FRAMEBUFFER, 0));

	glEnable(GL_TEXTURE_2D);
	defer(glBindTexture(GL_TEXTURE_2D, 0));

	Array<GLenum> drawBuffers{defaultAllocator()};

	auto addRT = [&drawBuffers, w, h](Texture& tex,
	                                  GLenum attachment,
	                                  s32 internalFormat,
	                                  GLenum format,
	                                  GLenum type)
	{
		glGenTextures(1, &tex.handle);
		glBindTexture(GL_TEXTURE_2D, tex.handle);
		glTexImage2D(GL_TEXTURE_2D,
		             0,
		             internalFormat,
		             (s32)w,
		             (s32)h,
		             0,
		             format,
		             type,
		             nullptr);
		tex.width  = w;
		tex.height = h;

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

		glFramebufferTexture2D(
		    GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, tex.handle, 0);

		if (attachment != GL_DEPTH_ATTACHMENT)
			append(drawBuffers, attachment);
	};

	addRT(b.textures[GBuffer::Diffuse],
	      GL_COLOR_ATTACHMENT0,
	      GL_RGB8,
	      GL_RGB,
	      GL_UNSIGNED_BYTE);
	addRT(b.textures[GBuffer::Specular],
	      GL_COLOR_ATTACHMENT1,
	      GL_RGBA8,
	      GL_RGBA,
	      GL_UNSIGNED_BYTE);
	addRT(b.textures[GBuffer::Normal],
	      GL_COLOR_ATTACHMENT2,
	      GL_RGB10_A2,
	      GL_RGBA,
	      GL_FLOAT);
	addRT(b.textures[GBuffer::Depth],
	      GL_DEPTH_ATTACHMENT,
	      GL_DEPTH_COMPONENT24,
	      GL_DEPTH_COMPONENT,
	      GL_FLOAT);

	glDrawBuffers((u32)len(drawBuffers), &drawBuffers[0]);

	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		return false;

	return true;
}
Beispiel #12
0
/*
 * a few things to note about this function; the debug messages are not operating in the limited memory space
 * which would be nice, but we would have to override the allocation tendencies of not only std::string
 * but also std::ostringstream and its like, which would be rather a tedious and error prone process.
 *
 * any who.  In this function we allocate a 1GB chunk of memory which we have exclusive control over and
 * we use the Free List Allocation method to divvy it up. we then allocate a multimap of pair<int,double>'s
 * multimap is good for testing for two reasons, it has horrible times in deallocation with the FreeLitAllocator
 * and it deallocates ALL of its memory when multimap<>::clear() is called. which the unordered_map variants
 * do not since they keep their hash tables until their destructors are called.
 */
void
memoryStuff( evq::EventQueue * eventQueue )
{
    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent("Creating DefaultAllocator.") );

    // wrapper for ::operator new() and ::operator delete()
    alloc::DefaultAllocator defaultAllocator( 0, nullptr );

    // pointer to our memory pool
    void * _mem_pool;

    // size of our memory pool: 1GB
    std::size_t _mem_size = 1024*1024*1024;

    // size of our memory pool: 0.5MB
    //std::size_t _mem_size = 1024*1024*0.5f;

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent("Allocating Memory Pool of size " + to_string(_mem_size) + "bytes.") );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent("Allocating FreeListAllocator, for Memory Pool.") );

    // allocate a free list allocator and allocate the memory pool and pass it to the free list allocator.
    alloc::SafeFreeListAllocator * fla = new( (alloc::SafeFreeListAllocator*)defaultAllocator ) alloc::SafeFreeListAllocator( _mem_size, _mem_pool = defaultAllocator.allocateBlock(_mem_size,0) );

    {
        alloc::ptr::weak_ptr<int> test_weak_ptr_outer;
        alloc::ptr::shared_ptr<int> test_shared_ptr_outer;
        {
            //alloc::ptr::shared_ptr<int> test_shared_ptr( new( (int*)*fla ) int(1), fla );
            alloc::ptr::shared_ptr<int> test_shared_ptr( alloc::ptr::allocate_shared<int>(fla, 1) );

            std::cout << *test_shared_ptr << std::endl;
            test_weak_ptr_outer = test_shared_ptr;
            test_shared_ptr_outer = test_shared_ptr;
        }
        if( auto t = test_weak_ptr_outer.lock() )
        {
            std::cout << *t << std::endl;
        }

        alloc::ptr::unique_ptr<int> test_unique_ptr_outer;
        {
            alloc::ptr::unique_ptr<int> test_unique_ptr( new( (int*)*fla ) int(1000), fla );

            test_unique_ptr_outer.swap( test_unique_ptr );

            {
                alloc::ptr::unique_ptr<int[]> test_array_unique_ptr( new( fla->allocateArray<int>( 100 ) ) int[100], fla );
                for( std::size_t i = 0; i < 100; ++i )
                {
                    test_array_unique_ptr[i] = i;
                }
            }
        }
        std::cout << *test_unique_ptr_outer << std::endl;
    }

    {
        //alloc::LockAllocator< alloc::LockAllocator< alloc::DefaultAllocator > > llalt(); // FIXME(dean): this line should not compile
        //llalt.printDebugInfo();
    }

    //std::ostringstream stream; // we don't have control over this memory
    std::basic_ostringstream<char> stream( std::basic_string<char>( alloc::stl_adapter<char>( fla ) ), std::ios_base::out );

    {
        // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
        eventQueue->queueEvent( new DebugListener::MessageEvent("Allocating IntMap from FreeListAllocator.") );

        // allocate a std::multimap<int,double> with our custom allocator adapters
        alloc::stl::map< int, double > * intmap = new( (alloc::stl::map< int, double >*)*fla ) alloc::stl::map< int, double >( fla );

        // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
        eventQueue->queueEvent( new DebugListener::MessageEvent("") );

        {
            // make 10000 pairs!
            for( std::size_t i = 0; i < 100000; ++i )
            {
                // insert a pair
                uint32_t key = Rand::Int( 0u, ~0u );
                double value = sqrt( double(key) );

                // here multimap will allocate space for a node that contains a pair<int,double> in it.
                //intmap->insert( std::pair<int,double>(key,value) );
                (*intmap)[key] = value;

                // print progress
                if( (i) % 1000 == 0 )
                {
                    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
                    eventQueue->queueEvent( new DebugListener::MessageEvent("Inserted " + to_string(i) + " pairs into IntMap on FreeListAllocator. Last pair: " + to_string(key) + "," + to_string(value) + ".") );
                }
            }
        }

        // clear the stringstream buffer
        stream.str( std::basic_string< char >( alloc::stl_adapter<char>(fla) ) );
        stream.clear();

        // put allocator debug info into stringstream buffer
        fla->printDebugInfo( stream );

        // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
        eventQueue->queueEvent( new DebugListener::MessageEvent( std::string( stream.str().c_str() ) ) );

        // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
        eventQueue->queueEvent( new DebugListener::MessageEvent("Deallocating all memory associated with IntMap in FreeListAllocator.") );

        // deallocate and destruct the multimap<int,double>
        fla->deallocate( intmap );
    }

    // clear the stringstream buffer
    stream.str( std::basic_string< char >( alloc::stl_adapter<char>(fla) ) );
    stream.clear();

    // put allocator debug info into stringstream buffer
    fla->printDebugInfo( stream );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent( std::string( stream.str().c_str() ) ) );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent( "cleaning up ... fla" ) );

    // destruct the FreeListAllocator
    defaultAllocator.deallocate( fla );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent( "cleaning up ... _mem_pool" ) );

    // deallocate the memory block
    defaultAllocator.deallocateBlock( _mem_pool );

    // clear the stringstream buffer
    //stream.str( std::basic_string< char >( alloc::stl_adapter<char>(fla) ) );
    //stream.clear();

    // put allocator debug info into stringstream buffer
    defaultAllocator.printDebugInfo( stream );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent( std::string( stream.str().c_str() ) ) );

    // we don't use the memory allocator with the events because we have yet to properly setup custom allocator deletion for events
    eventQueue->queueEvent( new DebugListener::MessageEvent( "complete." ) );
}
Beispiel #13
0
void Room::generate(bool northDoor,
                    bool eastDoor,
                    bool southDoor,
                    bool westDoor)
{
	if (m_generated)
		return;

	if (!m_mesh)
		m_mesh = defaultAllocator().makeNew<Mesh>();

	std::vector<std::vector<TileId>> mapGrid(size.x,
	                                         std::vector<TileId>(size.y));

	TileId emptyTile     = {-1, -1};
	TileId lightWoodTile = {0, 11};
	TileId darkWoodTile  = {0, 0};
	RandomTileSet stoneTiles;

	for (int i = 1; i < 3; i++)
		stoneTiles.emplace_back(i, 15);
	RandomTileSet darkRockTiles;
	for (int i = 0; i < 4; i++)
		darkRockTiles.emplace_back(i, 0);
	RandomTileSet colorfulTiles;
	for (int i = 3; i < 12; i++)
		colorfulTiles.emplace_back(i, 15);

	for (int i = 0; i < size.x; i++)
	{
		for (int j = 0; j < size.y; j++)
			mapGrid[i][j] = emptyTile;
	}

	TileId tile =
	    colorfulTiles[m_random.getInt(0, (u32)len(colorfulTiles) - 1)];

	const Room::Size s = size;
	for (int i = 0; i < s.x; i++)
	{
		for (int j = 0; j < s.y; j++)
			mapGrid[i][j] = tile;
	}

	const s32 h = Height;
	for (int i = 0; i < size.x; i++)
	{
		for (int j = 0; j < size.y; j++)
		{
			if (mapGrid[i][j] != emptyTile)
			{
				addTileSurface(
				    Vector3{i, 0, j}, TileSurfaceFace::Up, mapGrid[i][j]);
				addTileSurface(
				    Vector3{i, 3, j}, TileSurfaceFace::Down, stoneTiles);
			}
#if 1 // Build Walls
			else
			{
				addTileSurface(
				    Vector3{i, h, j}, TileSurfaceFace::Up, stoneTiles);
			}

			for (int k = 0; k < h; k++)
			{
				if (mapGrid[i][j] == emptyTile)
				{
					if (i > 0)
					{
						if (mapGrid[i - 1][j] != emptyTile)
							addTileSurface(Vector3{i, k, j},
							               TileSurfaceFace::Left,
							               stoneTiles);
					}

					if (i < size.x - 1)
					{
						if (mapGrid[i + 1][j] != emptyTile)
							addTileSurface(Vector3{i + 1, k, j},
							               TileSurfaceFace::Right,
							               stoneTiles);
					}

					if (j > 0)
					{
						if (mapGrid[i][j - 1] != emptyTile)
							addTileSurface(Vector3{i, k, j},
							               TileSurfaceFace::Back,
							               stoneTiles);
					}

					if (j < size.y - 1)
					{
						if (mapGrid[i][j + 1] != emptyTile)
							addTileSurface(Vector3{i, k, j + 1},
							               TileSurfaceFace::Front,
							               stoneTiles);
					}
				}
				else
				{
					if (i == 0)
					{
						if (westDoor)
						{
							if (j != size.y / 2)
								addTileSurface(Vector3{i, k, j},
								               TileSurfaceFace::Right,
								               stoneTiles);
						}
						else
						{
							addTileSurface(Vector3{i, k, j},
							               TileSurfaceFace::Right,
							               stoneTiles);
						}
					}
					else if (i == size.x - 1)
					{
						if (eastDoor)
						{
							if (j != size.y / 2)
								addTileSurface(Vector3{i + 1, k, j},
								               TileSurfaceFace::Left,
								               stoneTiles);
						}
						else
						{
							addTileSurface(Vector3{i + 1, k, j},
							               TileSurfaceFace::Left,
							               stoneTiles);
						}
					}
					if (j == 0)
					{
						if (northDoor)
						{
							if (i != size.x / 2)
								addTileSurface(Vector3{i, k, j},
								               TileSurfaceFace::Front,
								               stoneTiles);
						}
						else
						{
							addTileSurface(Vector3{i, k, j},
							               TileSurfaceFace::Front,
							               stoneTiles);
						}
					}
					else if (j == size.y - 1)
					{
						if (southDoor)
						{
							if (i != size.x / 2)
								addTileSurface(Vector3{i, k, j + 1},
								               TileSurfaceFace::Back,
								               stoneTiles);
						}
						else
						{
							addTileSurface(Vector3{i, k, j + 1},
							               TileSurfaceFace::Back,
							               stoneTiles);
						}
					}
				}
			}
#endif
		}
	}

	m_meshData.generateNormals();
	m_mesh->addData(m_meshData);

	addComponent<MeshRenderer>(m_mesh, material);

	m_generated = true;
}
Beispiel #14
0
Room::~Room()
{
	if (m_mesh)
		defaultAllocator().makeDelete(m_mesh);
}
ByteStreamHandleBuf<Storage, CharType, IsMutable>::ByteStreamHandleBuf(
    size_t inSize)
  : mStorage(defaultAllocator().allocateByteString<
        dbal::FunctionContext, dbal::DoZero, dbal::ThrowBadAlloc>(inSize)),
    mPos(0) { }