mirror of
https://github.com/SFML/SFML.git
synced 2024-11-29 14:51:06 +08:00
85a4e5155e
Also made the required changed for Rdoc to the system module and generated rdoc documentation for both modules. It's safe to say now that rbSFML is available to be used for at least opening up a window and opengl context and render something in opengl. git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1658 4e206d99-4929-0410-ac5d-dfc041789085
273 lines
8.6 KiB
C++
273 lines
8.6 KiB
C++
/* rbSFML - Copyright (c) 2010 Henrik Valter Vogelius Hansson - groogy@groogy.se
|
|
* This software is provided 'as-is', without any express or
|
|
* implied warranty. In no event will the authors be held
|
|
* liable for any damages arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute
|
|
* it freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented;
|
|
* you must not claim that you wrote the original software.
|
|
* If you use this software in a product, an acknowledgment
|
|
* in the product documentation would be appreciated but
|
|
* is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such,
|
|
* and must not be misrepresented as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any
|
|
* source distribution.
|
|
*/
|
|
|
|
#include "Vector2.hpp"
|
|
#include "main.hpp"
|
|
|
|
VALUE globalVector2Class;
|
|
|
|
/* Internal function
|
|
* Forces the argument someValue to be a Vector2. IF it can convert it then it will.
|
|
* So you can always safely asume that this function returns a Vector2 object.
|
|
* If it fails then an exception will be thrown.
|
|
*/
|
|
VALUE Vector2_ForceType( VALUE someValue )
|
|
{
|
|
if( rb_obj_is_kind_of( someValue, rb_cArray ) == Qtrue )
|
|
{
|
|
VALUE arg1 = rb_ary_entry( someValue, 0 );
|
|
VALUE arg2 = rb_ary_entry( someValue, 1 );
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, arg1, arg2 );
|
|
}
|
|
else if( rb_obj_is_kind_of( someValue, globalVector2Class ) == Qtrue )
|
|
{
|
|
return someValue;
|
|
}
|
|
else
|
|
{
|
|
rb_raise( rb_eRuntimeError, "expected Array or Vector2" );
|
|
}
|
|
}
|
|
|
|
/* Internal function
|
|
* Will copy the x and y from aSource to self.
|
|
*/
|
|
static void Vector2_internal_CopyFrom( VALUE self, VALUE aSource )
|
|
{
|
|
VALUE vectorSource = Vector2_ForceType( aSource );
|
|
VALUE x = rb_funcall( vectorSource, rb_intern( "x" ), 0 );
|
|
VALUE y = rb_funcall( vectorSource, rb_intern( "y" ), 0 );
|
|
|
|
rb_funcall( self, rb_intern( "x=" ), 1, x );
|
|
rb_funcall( self, rb_intern( "y=" ), 1, y );
|
|
rb_iv_set( self, "@dataType", rb_iv_get( vectorSource, "@dataType" ) );
|
|
}
|
|
|
|
/* Internal function
|
|
* Validate that the passed types are the same and numeric.
|
|
*/
|
|
static void Vector2_internal_ValidateTypes( VALUE aFirst, VALUE aSecond )
|
|
{
|
|
if( CLASS_OF( aFirst ) != CLASS_OF( aSecond ) )
|
|
{
|
|
rb_raise( rb_eRuntimeError, "x and y must be of same type" );
|
|
}
|
|
|
|
if( rb_obj_is_kind_of( aFirst, rb_cNumeric ) == Qfalse )
|
|
{
|
|
rb_raise( rb_eRuntimeError, "x and y must be numeric!" );
|
|
}
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Negate( VALUE self )
|
|
{
|
|
VALUE x = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE y = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE negatedX = rb_funcall( x, rb_intern( "-@" ), 0 );
|
|
VALUE negatedY = rb_funcall( y, rb_intern( "-@" ), 0 );
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, negatedX, negatedY );
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Add( VALUE self, VALUE aRightOperand )
|
|
{
|
|
VALUE rightVector = Vector2_ForceType( aRightOperand );
|
|
// Get values
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( rightVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( rightVector, rb_intern( "y" ), 0 );
|
|
|
|
// Do calculation
|
|
VALUE newX = rb_funcall( leftX, rb_intern( "+" ), 1, rightX );
|
|
VALUE newY = rb_funcall( leftY, rb_intern( "+" ), 1, rightY );
|
|
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, newX, newY );
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Subtract( VALUE self, VALUE aRightOperand )
|
|
{
|
|
VALUE rightVector = Vector2_ForceType( aRightOperand );
|
|
// Get values
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( rightVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( rightVector, rb_intern( "y" ), 0 );
|
|
|
|
// Do calculation
|
|
VALUE newX = rb_funcall( leftX, rb_intern( "-" ), 1, rightX );
|
|
VALUE newY = rb_funcall( leftY, rb_intern( "-" ), 1, rightY );
|
|
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, newX, newY );
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Multiply( VALUE self, VALUE aRightOperand )
|
|
{
|
|
VALUE rightVector = Vector2_ForceType( aRightOperand );
|
|
// Get values
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( rightVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( rightVector, rb_intern( "y" ), 0 );
|
|
|
|
// Do calculation
|
|
VALUE newX = rb_funcall( leftX, rb_intern( "*" ), 1, rightX );
|
|
VALUE newY = rb_funcall( leftY, rb_intern( "*" ), 1, rightY );
|
|
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, newX, newY );
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Divide( VALUE self, VALUE aRightOperand )
|
|
{
|
|
VALUE rightVector = Vector2_ForceType( aRightOperand );
|
|
// Get values
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( rightVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( rightVector, rb_intern( "y" ), 0 );
|
|
|
|
// Do calculation
|
|
VALUE newX = rb_funcall( leftX, rb_intern( "/" ), 1, rightX );
|
|
VALUE newY = rb_funcall( leftY, rb_intern( "/" ), 1, rightY );
|
|
|
|
return rb_funcall( globalVector2Class, rb_intern( "new" ), 2, newX, newY );
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_Equal( VALUE self, VALUE anArgument )
|
|
{
|
|
VALUE aVector = Vector2_ForceType( anArgument );
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( aVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( aVector, rb_intern( "y" ), 0 );
|
|
|
|
if( rb_funcall( leftX, rb_intern( "==" ), 1, rightX ) == Qtrue &&
|
|
rb_funcall( leftY, rb_intern( "==" ), 1, rightY ) == Qtrue )
|
|
{
|
|
return Qtrue;
|
|
}
|
|
else
|
|
{
|
|
return Qfalse;
|
|
}
|
|
}
|
|
|
|
/* */
|
|
static VALUE Vector2_StrictEqual( VALUE self, VALUE anArgument )
|
|
{
|
|
VALUE aVector = Vector2_ForceType( anArgument );
|
|
VALUE leftX = rb_funcall( self, rb_intern( "x" ), 0 );
|
|
VALUE leftY = rb_funcall( self, rb_intern( "y" ), 0 );
|
|
VALUE rightX = rb_funcall( aVector, rb_intern( "x" ), 0 );
|
|
VALUE rightY = rb_funcall( aVector, rb_intern( "y" ), 0 );
|
|
|
|
if( rb_funcall( leftX, rb_intern( "eql?" ), 1, rightX ) == Qtrue &&
|
|
rb_funcall( leftY, rb_intern( "eql?" ), 1, rightY ) == Qtrue )
|
|
{
|
|
return Qtrue;
|
|
}
|
|
else
|
|
{
|
|
return Qfalse;
|
|
}
|
|
}
|
|
|
|
/* call-seq:
|
|
* Vector2.new() -> vector
|
|
* Vector2.new([x,y]) -> vector
|
|
* Vector2.new(vector) -> vector
|
|
* Vector2.new(x,y) -> vector
|
|
*
|
|
* Create a new vector instance.
|
|
*/
|
|
static VALUE Vector2_Initialize( VALUE self, VALUE someArgs )
|
|
{
|
|
long arrayLength = RARRAY_LEN( someArgs );
|
|
rb_iv_set( self, "@x", INT2NUM( 0 ) );
|
|
rb_iv_set( self, "@y", INT2NUM( 0 ) );
|
|
|
|
if( arrayLength == 0 )
|
|
{
|
|
// Nothing needs to be done
|
|
}
|
|
else if( arrayLength == 1 )
|
|
{
|
|
Vector2_internal_CopyFrom( self, rb_ary_entry( someArgs, 0 ) );
|
|
}
|
|
else if( arrayLength == 2 )
|
|
{
|
|
VALUE arg1 = rb_ary_entry( someArgs, 0 );
|
|
VALUE arg2 = rb_ary_entry( someArgs, 1 );
|
|
Vector2_internal_ValidateTypes( arg1, arg2 );
|
|
|
|
rb_iv_set( self, "@x", arg1 );
|
|
rb_iv_set( self, "@y", arg2 );
|
|
}
|
|
|
|
rb_iv_set( self, "@dataType", CLASS_OF( rb_iv_get( self, "@x" ) ) );
|
|
return self;
|
|
}
|
|
|
|
void Init_Vector2( void )
|
|
{
|
|
/* SFML namespace which contains the classes of this module. */
|
|
VALUE sfml = rb_define_module( "SFML" );
|
|
/* SFML::Vector2 is a simple class that defines a mathematical vector with two coordinates (x and y).
|
|
*
|
|
* It can be used to represent anything that has two dimensions: a size, a point, a velocity, etc.
|
|
*
|
|
* This class differs from the C++ version. It will accept any value that is Numeric and both x and y must be of the same class.
|
|
*
|
|
* v1 = SFML::Vector2.new(16.5, 24.0)
|
|
* v1.x = 18.2
|
|
* y = v1.y
|
|
*
|
|
* v2 = v1 * v1;
|
|
* v3 = SFML::Vector2.new
|
|
* v3 = v1 + v2
|
|
*
|
|
* different = (v2 != v3);
|
|
*/
|
|
globalVector2Class = rb_define_class_under( sfml, "Vector2", rb_cObject );
|
|
|
|
// Instance methods
|
|
rb_define_method( globalVector2Class, "initialize", Vector2_Initialize, -2 );
|
|
rb_define_method( globalVector2Class, "eql?", Vector2_StrictEqual, 1 );
|
|
|
|
// Instance operators
|
|
rb_define_method( globalVector2Class, "-@", Vector2_Negate, 0 );
|
|
rb_define_method( globalVector2Class, "+", Vector2_Add, 1 );
|
|
rb_define_method( globalVector2Class, "-", Vector2_Subtract, 1 );
|
|
rb_define_method( globalVector2Class, "*", Vector2_Multiply, 1 );
|
|
rb_define_method( globalVector2Class, "/", Vector2_Divide, 1 );
|
|
rb_define_method( globalVector2Class, "==", Vector2_Equal, 1 );
|
|
|
|
// Attribute accessors
|
|
rb_define_attr( globalVector2Class, "x", 1, 1 );
|
|
rb_define_attr( globalVector2Class, "y", 1, 1 );
|
|
}
|