resman: Minimal implementation of texture loading

engine/client/cl_main.c

@@ -3071,6 +3071,8 @@ void CL_Init( void )
 
 	CL_InitLocal();
 
+	RM_Init();  // init resource manager
+
 	VID_Init();	// init video
 	S_Init();	// init sound
 

engine/client/ref_common.c

@@ -18,12 +18,6 @@ convar_t *gl_msaa_samples;
 convar_t *gl_clear;
 convar_t *r_refdll;
 
-void R_GetTextureParms( int *w, int *h, int texnum )
-{
-	if( w ) *w = REF_GET_PARM( PARM_TEX_WIDTH, texnum );
-	if( h ) *h = REF_GET_PARM( PARM_TEX_HEIGHT, texnum );
-}
-
 /*
 ================
 GL_FreeImage

engine/client/ref_common.h

@@ -36,11 +36,12 @@ extern struct ref_state_s ref;
 extern ref_globals_t refState;
 
 // handy API wrappers
-void R_GetTextureParms( int *w, int *h, int texnum );
 #define REF_GET_PARM( parm, arg ) ref.dllFuncs.RefGetParm( (parm), (arg) )
 #define GL_LoadTextureInternal( name, pic, flags ) ref.dllFuncs.GL_LoadTextureFromBuffer( (name), (pic), (flags), false )
 #define GL_UpdateTextureInternal( name, pic, flags ) ref.dllFuncs.GL_LoadTextureFromBuffer( (name), (pic), (flags), true )
-#define R_GetBuiltinTexture( name ) RM_LoadTexture( (name), 0, 0, 0 )
+
+#define R_GetTextureParms( WP, HP, T )  RM_GetTextureParams( WP, HP, T )
+#define R_GetBuiltinTexture( NAME )     RM_LoadTexture( NAME, 0, 0, 0 )
 
 void GL_RenderFrame( const struct ref_viewpass_s *rvp );
 

engine/resman/texture.c

@@ -1,18 +1,209 @@
 #include <common/system.h>
+#include <common/common.h>
 
 #include "texture.h"
 
-int RM_FindTexture( const char *name )
+
+////////////////////////////////////////////////////////////////////////////////
+// Defines, macros
+
+#define MAX_TEXTURES	    (8096)
+#define TEXTURES_HASH_SIZE	(MAX_TEXTURES)
+
+#define MAX_LIGHTMAPS	    (256)
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Structs
+
+typedef struct rm_texture_s {
+	char name[256];
+	int width;
+	int height;
+	int flags;
+
+	uint number;
+
+	uint   hash_value;
+	struct rm_texture_s *next_hash;
+} rm_texture_t;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Global state
+
+static struct {
+	rm_texture_t  textures[MAX_TEXTURES];
+	rm_texture_t* textures_hash_table[TEXTURES_HASH_SIZE];
+	uint          textures_count;
+
+	int default_texture;
+	int particle_texture;
+	int white_texture;
+	int gray_texture;
+	int black_texture;
+	int solidsky_texture;
+	int alphasky_texture;
+	int lightmap_textures[MAX_LIGHTMAPS];
+	int dlight_texture;
+	int cinematic_texture;
+} RM_TextureManager;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Local
+
+static rm_texture_t* AllocTexture( const char* name, int flags );
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Public methods
+
+void RM_Init()
 {
-	Sys_Error( "Unimplemented RM_FindTexture. Name %s", name );
+	// Reset texture manager
+	memset( &RM_TextureManager, 0, sizeof( RM_TextureManager ));
+
+	// Create unused 0-entry
+	const char *name = "*unused*";
+	Q_strncpy( RM_TextureManager.textures[0].name, name, sizeof( RM_TextureManager.textures[0].name ));
+
+	uint hash_value = COM_HashKey( name, TEXTURES_HASH_SIZE );
+	RM_TextureManager.textures[0].hash_value = hash_value;
+	RM_TextureManager.textures[0].next_hash = RM_TextureManager.textures_hash_table[hash_value];
+	RM_TextureManager.textures_hash_table[hash_value] = &(RM_TextureManager.textures[0]);
+	RM_TextureManager.textures_count = 1;
+
+	// TODO: Create internal textures
 }
 
 int RM_LoadTexture( const char *name, const byte *buf, size_t size, int flags )
 {
-	Sys_Error( "Unimplemented RM_LoadTexture. Name %s, size %d", name, size );
+	rgbdata_t    *picture;
+	rm_texture_t *texture;
+
+	Con_Reportf( "RM_LoadTexture. Name %s, size %d\n", name, size );
+
+	// TODO: Check name
+	//if( !Common_CheckTexName( name ))
+	//	return 0;
+
+	// TODO: Check cache
+	//if(( tex = Common_TextureForName( name )))
+	//	return (tex - vk_textures);
+
+	// TODO: Bit magic
+	//if( FBitSet( flags, TF_NOFLIP_TGA ))
+	//	SetBits( picFlags, IL_DONTFLIP_TGA );
+
+	//if( FBitSet( flags, TF_KEEP_SOURCE ) && !FBitSet( flags, TF_EXPAND_SOURCE ))
+	//	SetBits( picFlags, IL_KEEP_8BIT );
+
+	// TODO: Flags magic
+	//Image_SetForceFlags( picFlags );
+
+	// Load image using engine
+	picture = FS_LoadImage( name, buf, size );
+	if( !picture ) return 0;
+
+	// Allocate texture
+	texture = AllocTexture( name, flags );
+	texture->width  = picture->width;
+	texture->height = picture->height;
+
+	// TODO: Prepare texture
+	//VK_ProcessImage( tex, pic );
+
+	// TODO: Upload texture
+	//if( !uploadTexture( tex, &pic, 1, false ))
+	//{
+	//	memset( tex, 0, sizeof( vk_texture_t ));
+	//	gEngine.FS_FreeImage( pic ); // release source texture
+	//	return 0;
+	//}
+
+	// TODO: Apply texture params
+	//VK_ApplyTextureParams( tex );
+
+	// Release source texture
+	FS_FreeImage( picture );
+
+	return texture->number;
 }
 
 void RM_FreeTexture( unsigned int texnum )
 {
-	Sys_Error( "Unimplemented RM_FreeTexture. TexNum %d", texnum );
+	Con_Reportf( "Unimplemented RM_FreeTexture. TexNum %d\n", texnum );
+}
+
+int RM_FindTexture( const char *name )
+{
+	Con_Reportf( "RM_FindTexture. Name %s\n", name );
+
+	return 0;
+}
+
+void RM_GetTextureParams( int* w, int* h, int texnum )
+{
+	ASSERT( texnum >= 0 && texnum < MAX_TEXTURES );
+
+	Con_Reportf( "RM_GetTextureParams. Texnum %d\n", texnum );
+	Con_Reportf( "Texnum %d is texture %s\n", RM_TextureManager.textures[texnum].name );
+
+	if (w) *w = RM_TextureManager.textures[texnum].width;
+	if (h) *h = RM_TextureManager.textures[texnum].height; 
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Local implementation
+
+rm_texture_t* AllocTexture( const char* name, int flags )
+{
+	rm_texture_t* texture;
+	uint i;
+
+	// Find a free rm_texture_t slot
+	for( 
+		i = 0, texture = &(RM_TextureManager.textures); 
+		i < RM_TextureManager.textures_count; 
+		i++, texture++
+	)
+	{
+		if( !texture->name[0] )
+		{
+			break;
+		}
+	}
+
+	// No holes, append to tail
+	if( i == RM_TextureManager.textures_count )
+	{
+		// Check textures
+		// TODO: Maybe it's worth realloc with increasing max textures?
+		if( RM_TextureManager.textures_count == MAX_TEXTURES )
+		{
+			Host_Error( "ResMan: The textures limit is exhausted\n" );
+			return NULL;
+		}
+
+		RM_TextureManager.textures_count++;
+	}
+
+	// Setup params
+	Q_strncpy( texture->name, name, sizeof( texture->name ) );
+
+	// Width and height will be set later
+	texture->width  = 0;
+	texture->height = 0;
+
+	texture->number = i; 
+	texture->flags = flags;
+
+	// Add to hash table
+	texture->hash_value = COM_HashKey( name, TEXTURES_HASH_SIZE );
+
+	RM_TextureManager.textures_hash_table[texture->hash_value] = texture;
+	texture->next_hash = RM_TextureManager.textures_hash_table[texture->hash_value];
+
+	return texture;
 }

engine/resman/texture.h

@@ -1,8 +1,12 @@
 #ifndef RM_TEXTURE_H
 #define RM_TEXTURE_H
 
-int  RM_FindTexture( const char *name );
+void RM_Init();
+
 int  RM_LoadTexture( const char *name, const byte *buf, size_t size, int flags );
 void RM_FreeTexture( unsigned int texnum );
 
+int  RM_FindTexture( const char *name );
+void RM_GetTextureParams( int *w, int *h, int texnum );
+
 #endif  // RM_TEXTURE_H