示例#1
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_append(lua_State* state)
{
  const char* filename = l_tools_toStringOrError(state, 1);
  const char* data = l_tools_toStringOrError(state, 2);
  filesystem_append(filename, data);
  return 2;
}
示例#2
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_contain(lua_State* state)  {
  const char* a = l_tools_toStringOrError(state, 1);
  const char* b = l_tools_toStringOrError(state, 2);
  if ( filesystem_contain(a, b))
    lua_pushboolean(state, 1);
  else
    lua_pushboolean(state, 0);
  return 1;
}
示例#3
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_compare(lua_State* state)  {
  const char* a = l_tools_toStringOrError(state, 1);
  const char* b = l_tools_toStringOrError(state, 2);
  int l = l_tools_toNumberOrError(state, 3);
  if ( filesystem_compare(a, b, l))
    lua_pushboolean(state, 1);
  else
    lua_pushboolean(state, 0);
  return 1;
}
示例#4
0
static int l_graphics_Shader_getExternVariable(lua_State* state) {
  l_assertType(state, 1, l_graphics_isShader); 
  l_graphics_Shader const* shader = l_graphics_toShader(state, 1);

  char const* name = l_tools_toStringOrError(state, 2);

  graphics_ShaderUniformInfo const* info = graphics_Shader_getUniform(&shader->shader, name);

  if(!info) {
    goto errout;
  }
  
  graphics_ShaderUniformType type =  graphics_shader_toMotorType(info->type);
  if(type == graphics_ShaderUniformType_none) {
    goto errout;
  }

  l_tools_pushEnum(state, type, l_graphics_ShaderUniformType);
  lua_pushnumber(state, graphics_shader_toMotorComponents(info->type));
  lua_pushnumber(state, info->elements);

  return 3;

errout:
  lua_pushnil(state);
  lua_pushnil(state);
  lua_pushnil(state);
  return 3;
}
示例#5
0
文件: audio.c 项目: ezhangle/motor
static int l_audio_newSource(lua_State *state) {
  char const* filename = l_tools_toStringOrError(state, 1);

  audio_SourceType type = audio_SourceType_stream;
  if(!lua_isnoneornil(state, 2)) {
    type = l_tools_toEnumOrError(state, 2, l_audio_SourceType);
  }

  // TODO handle load errors
  switch(type) {
  case audio_SourceType_static:
    {
      audio_StaticSource *src = lua_newuserdata(state, sizeof(audio_StaticSource));
      audio_loadStatic(src, filename);
      lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.staticMT);
      break;
    }

  case audio_SourceType_stream:
    {
      audio_StreamSource *src = lua_newuserdata(state, sizeof(audio_StreamSource));
      audio_loadStream(src, filename);
      lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.streamMT);
      break;
    }
  }
  

  lua_setmetatable(state, -2);

  return 1;
}
示例#6
0
static int l_geometry_rectangle(lua_State* state) {
  const char* type = l_tools_toStringOrError(state, 1);
  float x = l_tools_toNumberOrError(state, 2);
  float y = l_tools_toNumberOrError(state, 3);
  float w = l_tools_toNumberOrError(state, 4);
  float h = l_tools_toNumberOrError(state, 5);
  float r = 0;
  if (lua_tonumber(state, 6)) r = luaL_checknumber(state, 6);
  float sx = 1;
  if (lua_tonumber(state, 7)) sx = luaL_checknumber(state, 7);
  float sy = 1;
  if (lua_tonumber(state, 8)) sy = luaL_checknumber(state, 8);
  float ox = 0;
  if (lua_tonumber(state, 9)) ox = luaL_checknumber(state, 9);
  float oy = 0;
  if (lua_tonumber(state, 10)) oy = luaL_checknumber(state, 10);

  if (strncmp(type,"line",4) == 0)
    graphics_geometry_fillRectangle(0, x, y, w, h, r, sx, sy, ox, oy);

  else if(strncmp(type,"fill", 4) == 0)
    graphics_geometry_fillRectangle(1, x, y, w, h, r, sx, sy, ox, oy);
  else
    {
      luaL_argerror(state,1,"expected string");
      lua_error(state);
    }
  return 1;
}
示例#7
0
文件: audio.c 项目: dns/CLove
static int l_audio_newSource(lua_State *state) {
	char const* filename = l_tools_toStringOrError(state, 1);
	const char* type = luaL_optstring(state, 2, "static");
	int err;

	if (strcmp(type,"stream") == 0) {
		audio_StreamSource *src = lua_newuserdata(state, sizeof(audio_StreamSource));
		err = audio_loadStream(src, filename);
		moduleData.audio_type = audio_type_stream;
	} else if (strcmp(type, "static") == 0) {
		audio_StaticSource *src = lua_newuserdata(state, sizeof(audio_StaticSource));
		err = audio_loadStatic(src, filename);
		moduleData.audio_type = audio_type_static;
	}

	lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.audioDataMT);
	if(err == -1){
		lua_pushstring(state, "Could not load sound file: ");
		lua_pushstring(state, lua_tostring(state, 1));
		lua_pushstring(state, ", reason: unknow file type");
		lua_concat(state, 3);
		return lua_error(state);
	}
	else if(err == 0){
		lua_pushstring(state, "Could not load sound file: ");
		lua_pushstring(state, lua_tostring(state, 1));
		lua_pushstring(state, ", reason: file does not exist");
		lua_concat(state, 3);
		return lua_error(state);
	}

	lua_setmetatable(state, -2);
	return 1;
}
示例#8
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_enumerate(lua_State* state) {
  int n = lua_gettop(state);

  const char * dir = l_tools_toStringOrError(state, 1);
  int error = PHYSFS_mount(dir, "/", 1);

  if (error != 1)
    return printf("%s %s %s \n", "Error: Directory or archive named : ", dir ," does not exist");

  char **rc = PHYSFS_enumerateFiles("/");
  char **i;
  int index = 1;

  if( n != 1 )
    return luaL_error(state, "Function s a single parameter.");

  lua_newtable(state);

  for (i = rc; *i != 0; i++)
    {
      lua_pushinteger(state, index);
      lua_pushstring(state, *i);
      lua_settable(state, -3);
      index++;
    }

  PHYSFS_freeList(rc);
  return 1;
}
示例#9
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_getRealDirectory(lua_State* state) {
  if (!PHYSFS_isInit())
    return 0;

  const char *dir = PHYSFS_getRealDir(l_tools_toStringOrError(state,1));
  lua_pushstring(state, dir);
  return 1;
}
示例#10
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_setSource(lua_State* state)
{
  const char* p = l_tools_toStringOrError(state, 1);

  int a = PHYSFS_addToSearchPath(p, 1);
  if(!a)
    printf("%s %s \n", "Couldn't set source", p);

  return 1;
}
示例#11
0
static int l_graphics_Font_getWrap(lua_State* state) {
  l_assertType(state, 1, l_graphics_isFont);

  graphics_Font* font = l_graphics_toFont(state, 1);

  char const* line = l_tools_toStringOrError(state, 2);
  int width = l_tools_toNumberOrError(state, 3);

  lua_pushinteger(state, graphics_Font_getWrap(font, line, width, NULL));
  return 1;
}
示例#12
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_isFile(lua_State* state) {
  if (!PHYSFS_isInit())
    return 0;

  const char* name = l_tools_toStringOrError(state, 1);
  if(!PHYSFS_isDirectory(name) && PHYSFS_exists(name))
    lua_pushboolean(state, 1);
  else
    lua_pushboolean(state, 0);
  return 1;
}
示例#13
0
static int l_graphics_Shader_send(lua_State *state) {
  l_assertType(state, 1, l_graphics_isShader); 
  l_graphics_Shader* shader = l_graphics_toShader(state, 1);

  char const* name = l_tools_toStringOrError(state, 2);

  graphics_ShaderUniformInfo const* info = graphics_Shader_getUniform(&shader->shader, name);

  switch(info->type) {
  case GL_INT:
    sendIntegers(state, shader, info);
    break;

  case GL_FLOAT:
    sendFloats(state, shader, info);
    break;

  case GL_BOOL:
    sendBooleans(state, shader, info);
    break;

  case GL_INT_VEC2:
  case GL_INT_VEC3:
  case GL_INT_VEC4:
    sendIntegerVectors(state, shader, info);
    break;

  case GL_FLOAT_VEC2:
  case GL_FLOAT_VEC3:
  case GL_FLOAT_VEC4:
    sendFloatVectors(state, shader, info);
    break;

  case GL_BOOL_VEC2:
  case GL_BOOL_VEC3:
  case GL_BOOL_VEC4:
    sendBooleanVectors(state, shader, info);
    break;

  case GL_FLOAT_MAT2:
  case GL_FLOAT_MAT3:
  case GL_FLOAT_MAT4:
    sendFloatMatrices(state, shader, info);
    break;

  case GL_SAMPLER_2D:
    sendSamplers(state, shader, info);
    break;

  };

  return 0;
}
示例#14
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_load(lua_State* state) {
  char const* filename = l_tools_toStringOrError(state, 1);
  char* data = NULL;
  int len = filesystem_read(filename, &data);
  if(len < 0) {
      lua_pushstring(state, "could not read file");
      return lua_error(state);
    }

  luaL_loadstring(state, data);
  free(data);
  return 1;
}
示例#15
0
static int l_geometry_circle(lua_State* state) {
  const char* type = l_tools_toStringOrError(state, 1);
  float x = l_tools_toNumberOrError(state, 2);
  float y = l_tools_toNumberOrError(state, 3);
  float radius = l_tools_toNumberOrError(state, 4);
  float segments = l_tools_toNumberOrError(state, 5);

  if (strncmp(type,"line",4) == 0)
    graphics_geometry_drawCircle(x, y, radius, segments);
  else if(strncmp(type,"fill", 4) == 0)
    graphics_geometry_fillCircle(x, y, radius, segments);
  return 1;
}
示例#16
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_read(lua_State* state) {
  // TODO implement max length
  char const* filename = l_tools_toStringOrError(state, 1);
  char* data = NULL;
  int len = filesystem_read(filename, &data);
  if(len < 0) {
      lua_pushstring(state, "could not read file");
      return lua_error(state);
    }

  lua_pushstring(state, data);
  free(data);
  lua_pushnumber(state, len);
  return 2;
}
示例#17
0
int static l_graphics_newShader(lua_State* state) {
  char const* vertexSrc = l_tools_toStringOrError(state, 1);
  char const* fragmentSrc = NULL;
  char * loadedFile1 = NULL;
  char * loadedFile2 = NULL;

  if(lua_isstring(state, 2)) {
    fragmentSrc = lua_tostring(state, 2);
    
    if(!isVertexShader(vertexSrc)) {
      // TODO
      int loadedFile1Size = filesystem_read(vertexSrc, &loadedFile1);
      (void) loadedFile1Size;
      if(!loadedFile1 || !isVertexShader(loadedFile1)) {
        free(loadedFile1);
        lua_pushstring(state, "input 1 is not a valid vertex shader");
        return lua_error(state);
      }
      vertexSrc = loadedFile1;
    }

    if(!isSingleFragmentShader(fragmentSrc)) {
      // TODO
      int loadedFile2Size = filesystem_read(fragmentSrc, &loadedFile2);
      (void)loadedFile2Size;

      if(!loadedFile2 || !isSingleFragmentShader(loadedFile2)) {
        free(loadedFile1);
        free(loadedFile2);
        lua_pushstring(state, "input 2 is not a valid fragment shader");
        return lua_error(state);
      }
      fragmentSrc = loadedFile2;
    }

  } else {
    if(isVertexShader(vertexSrc)) {
      // nothing required
    } else if(isSingleFragmentShader(vertexSrc)) {
      fragmentSrc = vertexSrc;
      vertexSrc = NULL;
    } else {
      // TODO
      int loadedFile1Size = filesystem_read(vertexSrc, &loadedFile1);
      (void) loadedFile1Size;
      if(!loadedFile1) {
        lua_pushstring(state, "could not open file");
        return lua_error(state);
      }

      if(isSingleFragmentShader(loadedFile1)) {
        fragmentSrc = loadedFile1;
        vertexSrc = NULL;
      } else if(isVertexShader(loadedFile1)) {
        vertexSrc = loadedFile1;
        fragmentSrc = NULL;
      } else {
        free(loadedFile1);
        lua_pushstring(state, "input is not a valid shader");
        return lua_error(state);
      }
    }
  }

  l_graphics_Shader * shader = lua_newuserdata(state, sizeof(l_graphics_Shader));
  graphics_ShaderCompileStatus status = graphics_Shader_new(&shader->shader, vertexSrc, fragmentSrc);
  if(status != graphics_ShaderCompileStatus_okay) {
    pushShaderInfoLog(state, &shader->shader);
    return lua_error(state);
  }

  lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.shaderMT);
  lua_setmetatable(state, -2);

  free(loadedFile1);
  free(loadedFile2);

  int const textureUnits = shader->shader.textureUnitCount;
  shader->referencedTextures = malloc(textureUnits * sizeof(int));
  for(int i = 0; i < textureUnits; ++i) {
    shader->referencedTextures[i] = LUA_NOREF;
  }

  return 1;
}
示例#18
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_exists(lua_State* state)
{
  const char* filename = l_tools_toStringOrError(state, 1);
  return filesystem_exists(filename);
}
示例#19
0
文件: system.c 项目: dns/CLove
static int l_system_setClipboardText(lua_State* state)
{
	const char* text = l_tools_toStringOrError(state, 1);
	system_setClipboardText(text);
	return 0;
}
示例#20
0
static int l_geometry_vertex(lua_State* state) {
  const char* type = l_tools_toStringOrError(state, 1);
  float x = l_tools_toNumberOrError(state, 2);
  float y = l_tools_toNumberOrError(state, 3);
  int _i = 0;
  int count = 1;
  
  if (lua_tonumber(state, 5))
    count = luaL_checknumber(state, 5);
  
  int dataSize = sizeof(int) * count;

  if(moduleData.currentDataSize < dataSize){
      free(moduleData.vertices);
      moduleData.vertices = (int*)malloc(dataSize);
      moduleData.currentDataSize = dataSize;
    }
  if(moduleData.vertices == 0)
    printf("Error: Could not allocate memory for l_geometry_vertex \n");
  //Check if we need to draw points of lines
  if (lua_istable(state, 4)) { //in this case draw lines
      // Push another reference to the table on top of the stack (so we know
      // where it is, and this function can work for negative, positive and
      // pseudo indices
      lua_pushvalue(state, 4);
      // stack now contains: -1 => table
      lua_pushnil(state);
      // stack now contains: -1 => nil; -2 => table
      while (lua_next(state, -2))
        {
          // stack now contains: -1 => value; -2 => key; -3 => table
          // copy the key so that lua_tostring does not modify the original
          lua_pushvalue(state, -2);
          // stack now contains: -1 => key; -2 => value; -3 => key; -4 => table
          const char *key = lua_tostring(state, -1);
          const char * value = lua_tostring(state, -2);
          int v = atoi(value);
          int i = atoi(key);

          //Put the key and the value of the table into an array
          moduleData.vertices[_i] = v; // second insert the value of the key
          _i ++;

          // pop value + copy of key, leaving original key
          lua_pop(state, 2);
          // stack now contains: -1 => key; -2 => table
        }
      // stack now contains: -1 => table (when lua_next returns 0 it pops the key
      // but does not push anything.)
      // Pop table
      lua_pop(state, 1);
      // Stack is now the same as it was on entry to this function
    }
  if (strncmp(type,"line",4) == 0)
    graphics_geometry_vertex(0,x,y,moduleData.vertices,count);
  else if (strncmp(type, "fill",4) == 0)
    graphics_geometry_vertex(1,x,y,moduleData.vertices,count);

  //free(vertices);
  return 1;
}
示例#21
0
文件: filesystem.c 项目: Murii/CLove
static int l_filesystem_remove(lua_State* state) {
  char const* file = l_tools_toStringOrError(state, 1);
  filesystem_remove(file);
  return 0;
}